+version = "1.6.1"

+checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"

+version = "0.160.0"

+checksum = "4b917ab47d7036977be4c984321af3e0de089229404d68ea9a286f50aa464697"

+version = "0.160.0"

+checksum = "021d80bea67458b8c90cc25bfdca6f911ea818a41905e370c1f310cced1dd07e"

+version = "0.160.0"

+checksum = "8bb89395306ecfc980d252f77a4038d8b8bb578a25c856b545cbeeb3fde8358e"

+version = "0.160.0"

+checksum = "84219d028a1954c4340ddde11adffe93eb83e476e942718fe926f4d99637cbbe"

+version = "0.160.0"

+checksum = "3908fdfa258c663d8ee407e6b4a205b0880e323b533c0df7edceafbd54a02fb6"

+version = "0.160.0"

+checksum = "34b50f19d5856b8e2b36150e89b53a6102ab096e8044e1f55fd6fef977b10d85"

+ "unicode-ident",

+version = "0.160.0"

+checksum = "76f83dcc451bcee8a99e284a583d5b3d82db5a200107a256a40ef132c4988f1b"

+version = "0.160.0"

+checksum = "f31236bdc6cbcae8af42d0b2db2fa8d812a8715b90a2ba5afb1132b37a4d0bbc"

+ "rustc-literal-escaper 0.0.7",

+version = "0.160.0"

+checksum = "3fc4edac740e896fba4b3b4d9c423083e3eac49947732561ddfb2377e1f57829"

+version = "0.160.0"

+checksum = "8efa119afc1bcadd821b27aa94332abf79c48ac0a972cb78932f63004ba4cdd9"

+ "ra-ap-rustc_abi",

+version = "0.160.0"

+checksum = "e6b1dc03abfabc7179393c282892c73a3f0e4bbd5f0b6c87ff42c2b142e68f57"

+version = "0.0.7"

+checksum = "8be87abb9e40db7466e0681dc8ecd9dcfd40360cb10b4c8fe24a7c4c3669b198"

+version = "1.0.24"

+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

+version = "0.1.4"

+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"

+ra-ap-rustc_lexer = { version = "0.160", default-features = false }

+ra-ap-rustc_parse_format = { version = "0.160", default-features = false }

+ra-ap-rustc_index = { version = "0.160", default-features = false }

+ra-ap-rustc_abi = { version = "0.160", default-features = false }

+ra-ap-rustc_pattern_analysis = { version = "0.160", default-features = false }

+ra-ap-rustc_ast_ir = { version = "0.160", default-features = false }

+ra-ap-rustc_type_ir = { version = "0.160", default-features = false }

+ra-ap-rustc_next_trait_solver = { version = "0.160", default-features = false }

+postcard = { version = "1.1.3", features = ["alloc"] }

+unexpected_cfgs = { level = "warn", check-cfg = [

+ 'cfg(bootstrap)',

+ "cfg(no_salsa_async_drops)",

+] }

+ "repr" | "rustc_scalable_vector" => attr_flags.insert(AttrFlags::HAS_REPR),

+ "rustc_scalable_vector" => attr_flags.insert(AttrFlags::HAS_REPR),

+ let mut current = None;

+ if let ast::Meta::TokenTreeMeta(attr) = &attr

+ && let Some(path) = attr.path()

+ if path.is1("repr")

+ && let Some(repr) = parse_repr_tt(&tt)

+ {

+ current = Some(repr);

+ } else if path.is1("rustc_scalable_vector")

+ && let mut tt = TokenTreeChildren::new(&tt)

+ && let Some(NodeOrToken::Token(scalable)) = tt.next()

+ && let Some(scalable) = ast::IntNumber::cast(scalable)

+ && let Ok(scalable) = scalable.value()

+ && let Ok(scalable) = scalable.try_into()

+ {

+ current = Some(ReprOptions {

+ scalable: Some(rustc_abi::ScalableElt::ElementCount(scalable)),

+ ..ReprOptions::default()

+ });

+ }

+ } else if let ast::Meta::PathMeta(attr) = &attr

+ && attr.path().is1("rustc_scalable_vector")

+ {

+ current = Some(ReprOptions {

+ scalable: Some(rustc_abi::ScalableElt::Container),

+ ..ReprOptions::default()

+ });

+ }

+

+ if let Some(current) = current {

+ Some(existing) => merge_repr(existing, current),

+ None => result = Some(current),

+ let ReprOptions { int, align, pack, flags, scalable, field_shuffle_seed: _ } = this;

+ if other.scalable.is_some() {

+ *scalable = other.scalable;

+ }

+use rustc_apfloat::ieee::{Double, Half, Quad, Single};

+ pub fn to_f128(&self) -> Quad {

+ pub fn to_f64(&self) -> Double {

+ pub fn to_f32(&self) -> Single {

+ pub fn to_f16(&self) -> Half {

+ AliasTy, Clause, Clauses, DbInterner, EarlyBinder, GenericArgs, ParamEnv,

+ StoredEarlyBinder, StoredTy, TraitRef, Ty, TyKind, fold::fold_tys, generics::Generics,

+ if let TyKind::Alias(AliasTy { kind: AliasTyKind::Projection { .. }, .. }) = t.kind() {

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Debug, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Clone, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Copy, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): PartialEq<[Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. })]>, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Eq, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): PartialOrd<[Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. })]>, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Ord, polarity:Positive), bound_vars: [] })

+ Clause(Binder { value: TraitPredicate(Alias(AliasTy { args: [#1], kind: Projection { def_id: TypeAliasId("Assoc") }, .. }): Hash, polarity:Positive), bound_vars: [] })

+use rustc_abi::Size;

+use rustc_apfloat::Float;

+use stdx::never;

+ LifetimeElisionKind, ParamEnvAndCrate, TyLoweringContext,

+ mir::{MirEvalError, MirLowerError, pad16},

+ Allocation, Const, ConstKind, Consts, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,

+ ScalarInt, StoredAllocation, StoredGenericArgs, Ty, TyKind, ValTreeKind, default_types,

+use super::mir::{interpret_mir, lower_body_to_mir};

+ krate: Crate,

+ let Ok(data_layout) = db.target_data_layout(krate) else {

+ return Const::error(interner);

+ };

+ let valtree = match (ty.kind(), value) {

+ (TyKind::Uint(uint), Literal::Uint(value, _)) => {

+ let size = uint.bit_width().map(Size::from_bits).unwrap_or(data_layout.pointer_size());

+ let scalar = ScalarInt::try_from_uint(*value, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ (TyKind::Uint(uint), Literal::Int(value, _)) => {

+ // `Literal::Int` is the default, so we also need to account for the type being uint.

+ let size = uint.bit_width().map(Size::from_bits).unwrap_or(data_layout.pointer_size());

+ let scalar = ScalarInt::try_from_uint(*value as u128, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ (TyKind::Int(int), Literal::Int(value, _)) => {

+ let size = int.bit_width().map(Size::from_bits).unwrap_or(data_layout.pointer_size());

+ let scalar = ScalarInt::try_from_int(*value, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ (TyKind::Bool, Literal::Bool(value)) => ValTreeKind::Leaf(ScalarInt::from(*value)),

+ (TyKind::Char, Literal::Char(value)) => ValTreeKind::Leaf(ScalarInt::from(*value)),

+ (TyKind::Float(float), Literal::Float(value, _)) => {

+ let size = Size::from_bits(float.bit_width());

+ let value = match float {

+ rustc_ast_ir::FloatTy::F16 => value.to_f16().to_bits(),

+ rustc_ast_ir::FloatTy::F32 => value.to_f32().to_bits(),

+ rustc_ast_ir::FloatTy::F64 => value.to_f64().to_bits(),

+ rustc_ast_ir::FloatTy::F128 => value.to_f128().to_bits(),

+ let scalar = ScalarInt::try_from_uint(value, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ }

+ (_, Literal::String(value)) => {

+ let u8_values = &interner.default_types().consts.u8_values;

+ ValTreeKind::Branch(Consts::new_from_iter(

+ interner,

+ value.as_str().as_bytes().iter().map(|&byte| u8_values[usize::from(byte)]),

+ (_, Literal::ByteString(value)) => {

+ let u8_values = &interner.default_types().consts.u8_values;

+ ValTreeKind::Branch(Consts::new_from_iter(

+ interner,

+ value.iter().map(|&byte| u8_values[usize::from(byte)]),

+ (_, Literal::CString(_)) => {

+ // FIXME:

+ return Const::error(interner);

+ }

+ _ => {

+ never!("mismatching type for literal");

+ return Const::error(interner);

+ }

+ Const::new_valtree(interner, ty, valtree)

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

+ let value = match value {

+ Some(value) => value,

+ None => {

+ return Const::error(interner);

+ }

+ };

+ let Ok(data_layout) = db.target_data_layout(krate) else {

+ return Const::error(interner);

+ };

+ let usize_ty = interner.default_types().types.usize;

+ let scalar = ScalarInt::try_from_uint(value, data_layout.pointer_size()).unwrap();

+ Const::new_valtree(interner, usize_ty, ValTreeKind::Leaf(scalar))

+}

+

+pub fn allocation_as_usize(ec: Allocation<'_>) -> u128 {

+ u128::from_le_bytes(pad16(&ec.memory, false))

+ Some(allocation_as_usize(ec))

+ Some(allocation_as_usize(ec))

+ ConstKind::Value(val) => {

+ if val.ty == default_types(db).types.usize {

+ Some(val.value.inner().to_leaf().to_uint_unchecked())

+ } else {

+ None

+ }

+ }

+pub fn allocation_as_isize(ec: Allocation<'_>) -> i128 {

+ i128::from_le_bytes(pad16(&ec.memory, true))

+}

+

+ Some(allocation_as_isize(ec))

+ Some(allocation_as_isize(ec))

+ ConstKind::Value(val) => {

+ if val.ty == default_types(db).types.isize {

+ Some(val.value.inner().to_leaf().to_int_unchecked())

+ } else {

+ None

+ }

+ }

+ let c = if is_signed { allocation_as_isize(c) } else { allocation_as_usize(c) as i128 };

+ return Const::new_from_allocation(

+ ctx.interner(),

+ &result,

+ ParamEnvAndCrate { param_env: ctx.table.param_env, krate: ctx.resolver.krate() },

+ );

+) -> Result<Allocation<'db>, ConstEvalError> {

+ ) -> Result<StoredAllocation, ConstEvalError> {

+ ) -> Result<StoredAllocation, ConstEvalError> {

+) -> Result<Allocation<'db>, ConstEvalError> {

+ ) -> Result<StoredAllocation, ConstEvalError> {

+ ) -> Result<StoredAllocation, ConstEvalError> {

+ consteval::allocation_as_usize,

+ next_solver::{Allocation, DbInterner, GenericArgs},

+ assert!(

+ error(simplify(e.clone())),

+ "Actual error was: {}\n{e:?}",

+ pretty_print_err(e.clone(), &db)

+ )

+ check(&r.memory, &r.memory_map);

+fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Allocation<'_>, ConstEvalError> {

+ assert_eq!(allocation_as_usize(r), 1);

+ |e| {

+ if let ConstEvalError::MirEvalError(MirEvalError::ConstEvalError(_, inner)) = e

+ && let ConstEvalError::MirLowerError(MirLowerError::Loop) = *inner

+ {

+ true

+ } else {

+ false

+ }

+ },

+ |e| {

+ if let ConstEvalError::MirEvalError(MirEvalError::ConstEvalError(_, inner)) = e

+ && let ConstEvalError::MirLowerError(MirLowerError::Loop) = *inner

+ {

+ true

+ } else {

+ false

+ }

+ },

+ Allocation, EarlyBinder, GenericArgs, ParamEnv, PolyFnSig, StoredEarlyBinder,

+ StoredGenericArgs, StoredTy, TraitRef, Ty, VariancesOf,

+ ) -> Result<Allocation<'db>, ConstEvalError>;

+ fn const_eval_static<'db>(&'db self, def: StaticId) -> Result<Allocation<'db>, ConstEvalError>;

+ AliasTy, Allocation, Clause, ClauseKind, Const, ConstKind, DbInterner,

+ ExistentialPredicate, FnSig, GenericArg, GenericArgKind, GenericArgs, ParamEnv, PolyFnSig,

+ Region, SolverDefId, StoredEarlyBinder, StoredTy, Term, TermKind, TraitRef, Ty, TyKind,

+ TypingMode, ValTree,

+ let TyKind::Alias(a) = ty.kind() else {

+ Either::Left(Ty::new_alias(f.interner, *alias)),

+ TypeAliasSignature::of(f.db, alias.kind.def_id().expect_type_alias())

+impl<'db> HirDisplay<'db> for Allocation<'db> {

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

+ render_const_scalar(f, &self.memory, &self.memory_map, self.ty)

+ }

+}

+

+ ConstKind::Value(value) => render_const_scalar_from_valtree(f, value.ty, value.value),

+ | TyKind::Alias(..)

+fn render_const_scalar_from_valtree<'db>(

+ f: &mut HirFormatter<'_, 'db>,

+ ty: Ty<'db>,

+ valtree: ValTree<'db>,

+) -> Result {

+ let param_env = ParamEnv::empty();

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

+ let ty = infcx.at(&ObligationCause::new(), param_env).deeply_normalize(ty).unwrap_or(ty);

+ render_const_scalar_from_valtree_inner(f, ty, valtree, param_env)

+}

+

+fn render_const_scalar_from_valtree_inner<'db>(

+ f: &mut HirFormatter<'_, 'db>,

+ ty: Ty<'db>,

+ valtree: ValTree<'db>,

+ _param_env: ParamEnv<'db>,

+) -> Result {

+ use TyKind;

+ match ty.kind() {

+ TyKind::Bool => write!(f, "{}", valtree.inner().to_leaf().try_to_bool().unwrap()),

+ TyKind::Char => {

+ let it = valtree.inner().to_leaf().to_u32();

+ let Ok(c) = char::try_from(it) else {

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

+ };

+ write!(f, "{c:?}")

+ }

+ TyKind::Int(_) => {

+ let it = valtree.inner().to_leaf().to_int_unchecked();

+ write!(f, "{it}")

+ }

+ TyKind::Uint(_) => {

+ let it = valtree.inner().to_leaf().to_uint_unchecked();

+ write!(f, "{it}")

+ }

+ TyKind::Float(fl) => match fl {

+ FloatTy::F16 => {

+ // FIXME(#17451): Replace with builtins once they are stabilised.

+ let it = f16::from_bits(valtree.inner().to_leaf().to_u16() as u128);

+ let s = it.to_string();

+ if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {

+ // Match Rust debug formatting

+ write!(f, "{s}.0")

+ } else {

+ write!(f, "{s}")

+ }

+ }

+ FloatTy::F32 => {

+ let it = f32::from_bits(valtree.inner().to_leaf().to_u32());

+ write!(f, "{it:?}")

+ }

+ FloatTy::F64 => {

+ let it = f64::from_bits(valtree.inner().to_leaf().to_u64());

+ write!(f, "{it:?}")

+ }

+ FloatTy::F128 => {

+ // FIXME(#17451): Replace with builtins once they are stabilised.

+ let it = f128::from_bits(valtree.inner().to_leaf().to_u128());

+ let s = it.to_string();

+ if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {

+ // Match Rust debug formatting

+ write!(f, "{s}.0")

+ } else {

+ write!(f, "{s}")

+ }

+ }

+ },

+ TyKind::Ref(_, inner_ty, _) => {

+ render_const_scalar_from_valtree_inner(f, inner_ty, valtree, _param_env)

+ }

+ TyKind::Str => {

+ let bytes = valtree

+ .inner()

+ .to_branch()

+ .iter()

+ .map(|konst| match konst.kind() {

+ ConstKind::Value(value) => Some(value.value.inner().to_leaf().to_u8()),

+ _ => None,

+ })

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

+ let Some(bytes) = bytes else { return f.write_str("<invalid-str>") };

+ let s = std::str::from_utf8(&bytes).unwrap_or("<utf8-error>");

+ write!(f, "{s:?}")

+ }

+ TyKind::Slice(inner_ty) | TyKind::Array(inner_ty, _) => {

+ let mut first = true;

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

+ for item in valtree.inner().to_branch() {

+ if !first {

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

+ } else {

+ first = false;

+ }

+ let ConstKind::Value(value) = item.kind() else {

+ return f.write_str("<invalid-const>");

+ };

+ render_const_scalar_from_valtree_inner(f, inner_ty, value.value, _param_env)?;

+ }

+ write!(f, "]")

+ }

+ TyKind::Tuple(tys) => {

+ let mut first = true;

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

+ for (inner_ty, item) in std::iter::zip(tys, valtree.inner().to_branch()) {

+ if !first {

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

+ } else {

+ first = false;

+ }

+ let ConstKind::Value(value) = item.kind() else {

+ return f.write_str("<invalid-const>");

+ };

+ render_const_scalar_from_valtree_inner(f, inner_ty, value.value, _param_env)?;

+ }

+ write!(f, ")")

+ }

+ TyKind::Adt(..) => {

+ // FIXME: ADTs, requires `adt_const_params`.

+ f.write_str("<adt>")

+ }

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

+ TyKind::FnPtr(_, _) | TyKind::RawPtr(_, _) => {

+ let it = valtree.inner().to_leaf().to_uint_unchecked();

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

+ ty.hir_fmt(f)

+ }

+ TyKind::Never => f.write_str("!"),

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

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

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

+ TyKind::CoroutineClosure(_, _) => f.write_str("<coroutine-closure>"),

+ TyKind::UnsafeBinder(_) => f.write_str("<unsafe-binder>"),

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

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

+ TyKind::Pat(_, _) => f.write_str("<pat>"),

+ TyKind::Error(..)

+ | TyKind::Placeholder(_)

+ | TyKind::Alias(..)

+ | TyKind::Param(_)

+ | TyKind::Bound(_, _)

+ | TyKind::Infer(_) => f.write_str("<placeholder-or-unknown-type>"),

+ TyKind::Dynamic(_, _) => f.write_str("<dyn-trait>"),

+ }

+}

+

+ TyKind::Alias(alias_ty @ AliasTy { kind: AliasTyKind::Projection { .. }, .. }) => {

+ TyKind::Alias(alias_ty @ AliasTy { kind: AliasTyKind::Opaque { def_id }, .. }) => {

+ let opaque_ty_id = match def_id {

+ TyKind::Alias(..) => write!(f, "{{alias}}")?,

+ AliasTy, Binder, Clause, Clauses, DbInterner, EarlyBinder, GenericArgs, Goal, ParamEnv,

+ ParamTy, SolverDefId, TraitPredicate, TraitRef, Ty, TypingMode, infer::DbInternerInferExt,

+ mk_param,

+ rustc_type_ir::TyKind::Alias(

+ proj @ AliasTy { kind: AliasTyKind::Projection { .. }, .. },

+ ) => match self.allow_self_projection {

+ AllowSelfProjection::Yes => {

+ let trait_ = proj.trait_def_id(interner);

+ let trait_ = match trait_ {

+ SolverDefId::TraitId(id) => id,

+ _ => unreachable!(),

+ };

+ if self.super_traits.is_none() {

+ self.super_traits = Some(

+ elaborate::supertrait_def_ids(interner, self.trait_.into())

+ .map(|super_trait| super_trait.0)

+ .collect(),

+ )

+ }

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

+ ControlFlow::Continue(())

+ } else {

+ ty.super_visit_with(self)

+ AllowSelfProjection::No => ty.super_visit_with(self),

+ },

+ if let rustc_type_ir::TyKind::Alias(AliasTy {

+ kind: AliasTyKind::Opaque { def_id },

+ ..

+ }) = ty.kind()

+ {

+ let id = match def_id {

+ AliasTyKind::Projection { def_id: res_assoc_ty.into() },

+ AliasTy::new_from_args(

+ self.interner(),

+ AliasTyKind::Projection { def_id: assoc_type.into() },

+ args,

+ ),

+ TyKind::Alias(AliasTy { kind: rustc_type_ir::Opaque { def_id }, args, .. }) => self

+ BoundConst::new(BoundVar::from_usize(i)),

+ AliasTy::new_from_args(

+ self.interner(),

+ rustc_type_ir::Projection { def_id: output_assoc_type.into() },

+ proj_args,

+ ),

+use rustc_abi::{AddressSpace, AlignFromBytesError, TargetDataLayoutError};

+ TargetDataLayoutError::InvalidAddressSpace { addr_space, cause, err } => {

+ TargetDataLayoutError::InvalidBits { kind, bit, cause, err } => format!(r#"invalid {kind} `{bit}` for `{cause}` in "data-layout": {err}"#),

+ TargetDataLayoutError::MissingAlignment { cause } => format!(r#"missing alignment for `{cause}` in "data-layout""#),

+ TargetDataLayoutError::InvalidAlignment { cause, err } => {

+ let (align, err_kind) = match err {

+ AlignFromBytesError::NotPowerOfTwo(align) => (align, "not a power of two"),

+ AlignFromBytesError::TooLarge(align) => (align, "too large"),

+ };

+ format!(r#"invalid alignment for `{cause}` in "data-layout": `{align}` is {err_kind}"#)

+ },

+ TargetDataLayoutError::InconsistentTargetArchitecture { dl, target } => {

+ TargetDataLayoutError::InconsistentTargetPointerWidth {

+ TargetDataLayoutError::InvalidBitsSize { err } => err,

+ TargetDataLayoutError::UnknownPointerSpecification { err } => format!(r#"use of unknown pointer specifier in "data-layout": {err}"#),

+ CanonicalVarKind, CanonicalVarKinds, ClauseKind, Const, ConstKind, DbInterner, FnSig,

+ Ok(Const::new_bound(self.interner, self.binder, BoundConst::new(var)))

+ var_kinds: CanonicalVarKinds::new_from_slice(&error_replacer.vars),

+ AliasTy::new_from_args(

+ table.interner(),

+ rustc_type_ir::Projection { def_id: output_assoc_type.into() },

+ args,

+ ),

+ AliasTy::new_from_args(

+ self.interner,

+ AliasTyKind::Opaque { def_id: opaque_ty_id },

+ args,

+ ),

+ AliasTy::new_from_args(interner, rustc_type_ir::Opaque { def_id }, args),

+ AliasTyKind::Projection { def_id: associated_ty.into() },

+ AliasTyKind::Projection { def_id: associated_ty.into() },

+ Allocation, AllocationData, DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv,

+ StoredAllocation, StoredConst, StoredGenericArgs, StoredTy, Ty, TyKind,

+ Constant {

+ konst: StoredConst,

+ ty: StoredTy,

+ },

+ Allocation {

+ allocation: StoredAllocation,

+ },

+ kind: OperandKind::Allocation {

+ allocation: Allocation::new(AllocationData { ty, memory: data, memory_map })

+ .store(),

+ OperandKind::Constant { .. }

+ | OperandKind::Static(_)

+ | OperandKind::Allocation { .. } => (),

+ OperandKind::Constant { .. } | OperandKind::Static(_) | OperandKind::Allocation { .. } => {}

+ OperandKind::Constant { .. } | OperandKind::Static(_) | OperandKind::Allocation { .. } => {}

+use rustc_abi::{Size, TargetDataLayout};

+ AliasTy, Allocation, AllocationData, Const, ConstKind, DbInterner, ErrorGuaranteed,

+ GenericArgs, Region, StoredTy, Ty, TyKind, TypingMode, UnevaluatedConst, ValTree,

+ InvalidConst,

+ | MirEvalError::InvalidConst

+ Self::InvalidConst => f.write_str("InvalidConst"),

+) -> Result<'db, (Result<'db, Allocation<'db>>, MirOutput)> {

+ let it: Result<'db, Allocation<'db>> = (|| {

+ let bytes = Box::from(bytes);

+ Ok(Allocation::new(AllocationData { ty, memory: bytes, memory_map }))

+ OperandKind::Allocation { allocation } => allocation.as_ref().ty,

+ OperandKind::Allocation { allocation } => {

+ self.allocate_allocation_in_heap(locals, allocation.as_ref())?

+ }

+ fn allocate_valtree_in_heap(

+ &mut self,

+ ty: Ty<'db>,

+ valtree: ValTree<'db>,

+ ) -> Result<'db, Interval> {

+ match ty.kind() {

+ TyKind::Bool => {

+ let value = valtree.inner().to_leaf().try_to_bool().unwrap();

+ let addr = self.heap_allocate(1, 1)?;

+ self.write_memory(addr, &[u8::from(value)])?;

+ Ok(Interval::new(addr, 1))

+ }

+ TyKind::Char => {

+ let value = valtree.inner().to_leaf().to_u32();

+ let addr = self.heap_allocate(4, 4)?;

+ self.write_memory(addr, &value.to_le_bytes())?;

+ Ok(Interval::new(addr, 4))

+ }

+ TyKind::Int(int_ty) => {

+ let size = int_ty.bit_width().unwrap_or(self.ptr_size() as u64);

+ let value = valtree.inner().to_leaf().to_int(Size::from_bytes(size));

+ let addr = self.heap_allocate(size as usize, size as usize)?;

+ self.write_memory(addr, &value.to_le_bytes()[..size as usize])?;

+ Ok(Interval::new(addr, size as usize))

+ }

+ TyKind::Uint(uint_ty) => {

+ let size = uint_ty.bit_width().unwrap_or(self.ptr_size() as u64);

+ let value = valtree.inner().to_leaf().to_uint(Size::from_bytes(size));

+ let addr = self.heap_allocate(size as usize, size as usize)?;

+ self.write_memory(addr, &value.to_le_bytes()[..size as usize])?;

+ Ok(Interval::new(addr, size as usize))

+ }

+ TyKind::Float(float_ty) => {

+ let size = float_ty.bit_width();

+ let value = valtree.inner().to_leaf().to_uint(Size::from_bytes(size));

+ let addr = self.heap_allocate(size as usize, size as usize)?;

+ self.write_memory(addr, &value.to_le_bytes()[..size as usize])?;

+ Ok(Interval::new(addr, size as usize))

+ }

+ TyKind::RawPtr(..) => {

+ let size = self.ptr_size();

+ let value = valtree.inner().to_leaf().to_uint(Size::from_bytes(size));

+ let addr = self.heap_allocate(size, size)?;

+ self.write_memory(addr, &value.to_le_bytes()[..size])?;

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

+ }

+ TyKind::Ref(_, inner_ty, _) => match inner_ty.kind() {

+ TyKind::Str => {

+ let bytes = valtree

+ .inner()

+ .to_branch()

+ .iter()

+ .map(|konst| match konst.kind() {

+ ConstKind::Value(value) => Ok(value.value.inner().to_leaf().to_u8()),

+ _ => not_supported!("unsupported const"),

+ })

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

+ let bytes_addr = self.heap_allocate(bytes.len(), 1)?;

+ self.write_memory(bytes_addr, &bytes)?;

+ let ref_addr = self.heap_allocate(self.ptr_size() * 2, self.ptr_size())?;

+ self.write_memory(ref_addr, &bytes_addr.to_bytes())?;

+ let mut len = [0; 16];

+ len[..size_of::<usize>()].copy_from_slice(&bytes.len().to_le_bytes());

+ self.write_memory(ref_addr.offset(self.ptr_size()), &len[..self.ptr_size()])?;

+ Ok(Interval::new(ref_addr, self.ptr_size() * 2))

+ }

+ TyKind::Slice(inner_ty) => {

+ let item_layout = self.layout(inner_ty)?;

+ let items = valtree

+ .inner()

+ .to_branch()

+ .iter()

+ .map(|konst| match konst.kind() {

+ ConstKind::Value(value) => {

+ self.allocate_valtree_in_heap(value.ty, value.value)

+ }

+ _ => not_supported!("unsupported const"),

+ })

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

+ let items_addr = self.heap_allocate(

+ items.len() * (item_layout.size.bits() as usize),

+ item_layout.align.bits_usize(),

+ )?;

+ for (i, item) in items.iter().enumerate() {

+ self.copy_from_interval(

+ items_addr.offset(i * (item_layout.size.bits() as usize)),

+ *item,

+ )?;

+ }

+ let ref_addr = self.heap_allocate(self.ptr_size() * 2, self.ptr_size())?;

+ self.write_memory(ref_addr, &items_addr.to_bytes())?;

+ let mut len = [0; 16];

+ len[..size_of::<usize>()].copy_from_slice(&items.len().to_le_bytes());

+ self.write_memory(ref_addr.offset(self.ptr_size()), &len[..self.ptr_size()])?;

+ Ok(Interval::new(ref_addr, self.ptr_size() * 2))

+ }

+ TyKind::Dynamic(..) => not_supported!("`dyn Trait` consts not supported yet"),

+ _ => {

+ let inner_addr = self.allocate_valtree_in_heap(inner_ty, valtree)?;

+ let ref_addr = self.heap_allocate(self.ptr_size(), self.ptr_size())?;

+ self.write_memory(ref_addr, &inner_addr.addr.to_bytes())?;

+ Ok(Interval::new(ref_addr, self.ptr_size()))

+ }

+ },

+ TyKind::Adt(_, _) | TyKind::Array(_, _) | TyKind::Tuple(_) => {

+ not_supported!(

+ "ADTs, arrays and tuples are unsupported in consts currently (requires `adt_const_params`)"

+ )

+ }

+ TyKind::Pat(_, _)

+ | TyKind::Slice(_)

+ | TyKind::FnDef(_, _)

+ | TyKind::Foreign(_)

+ | TyKind::Dynamic(_, _)

+ | TyKind::UnsafeBinder(..)

+ | TyKind::FnPtr(..)

+ | TyKind::Closure(_, _)

+ | TyKind::CoroutineClosure(_, _)

+ | TyKind::Coroutine(_, _)

+ | TyKind::CoroutineWitness(_, _)

+ | TyKind::Never

+ | TyKind::Alias(..)

+ | TyKind::Param(_)

+ | TyKind::Bound(..)

+ | TyKind::Placeholder(_)

+ | TyKind::Infer(_)

+ | TyKind::Str

+ | TyKind::Error(_) => not_supported!("unsupported const"),

+ }

+ }

+

+ match konst.kind() {

+ ConstKind::Value(value) => self.allocate_valtree_in_heap(value.ty, value.value),

+ ConstKind::Unevaluated(UnevaluatedConst { def: const_id, args: subst }) => {

+ let allocation = match id {

+ self.allocate_allocation_in_heap(locals, allocation)

+ }

+ }

+

+ fn allocate_allocation_in_heap(

+ &mut self,

+ locals: &Locals,

+ allocation: Allocation<'db>,

+ ) -> Result<'db, Interval> {

+ let AllocationData { ty, memory: ref v, ref memory_map } = *allocation;

+ let (size, align) = self.size_align_of(allocation.ty, locals)?.unwrap_or((v.len(), 1));

+ return Err(MirEvalError::InvalidConst);

+ TyKind::Alias(AliasTy { kind: AliasTyKind::Projection { .. }, .. }) => {

+ | TyKind::Alias(..)

+ let allocation = self.db.const_eval_static(st).map_err(|e| {

+ self.allocate_allocation_in_heap(locals, allocation)?

+ c: Allocation<'db>,

+ let data = evaluator.allocate_allocation_in_heap(locals, c)?;

+ 8 => Box::new(f.to_f64().to_bits().to_le_bytes()),

+ 4 => Box::new(f.to_f32().to_bits().to_le_bytes()),

+ if matches!(const_id, GeneralConstId::AnonConstId(_)) {

+ // FIXME:

+ not_supported!("anon consts are not supported yet in const eval");

+ }

+ let konst = Const::new_unevaluated(

+ self.interner(),

+ UnevaluatedConst { def: const_id.into(), args: subst },

+ );

+ next_solver::{

+ Allocation, AllocationData, Const, ConstKind, Region, RegionKind, StoredConst,

+ StoredGenericArgs, StoredTy,

+ },

+ OperandKind::Allocation { allocation } => {

+ let alloc = allocation.as_ref();

+ let mut ty = alloc.ty.store();

+ self.fill_ty(&mut ty)?;

+ *allocation = Allocation::new(AllocationData {

+ ty: ty.as_ref(),

+ memory: alloc.memory.clone(),

+ // FIXME: Do we need to fill the memory map too?

+ memory_map: alloc.memory_map.clone(),

+ })

+ .store();

+ }

+ OperandKind::Allocation { allocation } => {

+ w!(self, "Allocation({})", self.hir_display(&allocation.as_ref()))

+ }

+mod allocation;

+pub use allocation::*;

+ pub u8_values: [Const<'db>; 256],

+ pub canonical_vars: CanonicalVarKinds<'db>,

+ pub consts: Consts<'db>,

+ let ty = CanonicalVarKinds::new_from_slice(slice);

+ let create_consts = |slice| {

+ let ty = Consts::new_from_slice(slice);

+ // We need to increase the refcount (forever), so that the types won't be freed.

+ let ty = ManuallyDrop::new(ty.store());

+ ty.as_ref()

+ };

+ let u8 = create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U8));

+ u8,

+ consts: DefaultConsts {

+ error: create_const(ConstKind::Error(ErrorGuaranteed)),

+ u8_values: std::array::from_fn(|u8_value| {

+ create_const(ConstKind::Value(ValueConst {

+ ty: u8,

+ value: ValTree::new(ValTreeKind::Leaf(ScalarInt::from(u8_value as u8))),

+ }))

+ }),

+ },

+ consts: create_consts(&[]),

+ BoundVariableKind::Region(BoundRegionKind::ClosureEnv),

+use std::{fmt, hash::Hash};

+

+use intern::{Interned, InternedRef, impl_internable};

+use macros::GenericTypeVisitable;

+use rustc_type_ir::GenericTypeVisitable;

+

+use crate::{

+ MemoryMap,

+ next_solver::{Ty, impl_stored_interned},

+};

+

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

+pub struct Allocation<'db> {

+ interned: InternedRef<'db, AllocationInterned>,

+}

+

+impl<'db> Allocation<'db> {

+ pub fn new(data: AllocationData<'db>) -> Self {

+ let data =

+ unsafe { std::mem::transmute::<AllocationData<'db>, AllocationData<'static>>(data) };

+ Self { interned: Interned::new_gc(AllocationInterned(data)) }

+ }

+}

+

+impl<'db> std::ops::Deref for Allocation<'db> {

+ type Target = AllocationData<'db>;

+

+ #[inline]

+ fn deref(&self) -> &Self::Target {

+ let inner = &self.interned.0;

+ unsafe { std::mem::transmute::<&AllocationData<'static>, &AllocationData<'db>>(inner) }

+ }

+}

+

+impl<'db, V: super::WorldExposer> GenericTypeVisitable<V> for Allocation<'db> {

+ fn generic_visit_with(&self, visitor: &mut V) {

+ if visitor.on_interned(self.interned).is_continue() {

+ (**self).generic_visit_with(visitor);

+ }

+ }

+}

+

+impl fmt::Debug for Allocation<'_> {

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

+ let AllocationData { ty, memory, memory_map } = &**self;

+ f.debug_struct("Allocation")

+ .field("ty", ty)

+ .field("memory", memory)

+ .field("memory_map", memory_map)

+ .finish()

+ }

+}

+

+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]

+pub(super) struct AllocationInterned(AllocationData<'static>);

+

+#[derive(Debug, PartialEq, Eq, GenericTypeVisitable)]

+pub struct AllocationData<'db> {

+ pub ty: Ty<'db>,

+ pub memory: Box<[u8]>,

+ pub memory_map: MemoryMap<'db>,

+}

+

+impl<'db> Hash for AllocationData<'db> {

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

+ let Self { ty, memory, memory_map: _ } = self;

+ ty.hash(state);

+ memory.hash(state);

+ }

+}

+

+impl_internable!(gc; AllocationInterned);

+impl_stored_interned!(AllocationInterned, Allocation, StoredAllocation);

+mod valtree;

+

+ TypeVisitable, WithCachedTypeInfo, inherent::IntoKind, relate::Relate,

+ ParamEnvAndCrate,

+ next_solver::{

+ AllocationData, impl_foldable_for_interned_slice, impl_stored_interned, interned_slice,

+ },

+use super::{DbInterner, ErrorGuaranteed, GenericArgs, Ty};

+

+pub use self::valtree::*;

+ pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderConst<'db>) -> Self {

+ pub fn new_bound(

+ interner: DbInterner<'db>,

+ index: DebruijnIndex,

+ bound: BoundConst<'db>,

+ ) -> Self {

+ pub fn new_valtree(interner: DbInterner<'db>, ty: Ty<'db>, kind: ValTreeKind<'db>) -> Self {

+ Const::new(interner, ConstKind::Value(ValueConst { ty, value: ValTree::new(kind) }))

+ }

+

+ pub fn new_from_allocation(

+ allocation: &AllocationData<'db>,

+ param_env: ParamEnvAndCrate<'db>,

+ allocation_to_const(

+ allocation.ty,

+ &allocation.memory,

+ &allocation.memory_map,

+ param_env,

+pub type PlaceholderConst<'db> = rustc_type_ir::PlaceholderConst<DbInterner<'db>>;

+ fn new_bound(interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundConst<'db>) -> Self {

+ ConstKind::Bound(BoundVarIndexKind::Bound(debruijn), BoundConst::new(var)),

+ Const::new(interner, ConstKind::Bound(BoundVarIndexKind::Canonical, BoundConst::new(var)))

+ fn new_placeholder(interner: DbInterner<'db>, param: PlaceholderConst<'db>) -> Self {

+pub type BoundConst<'db> = rustc_type_ir::BoundConst<DbInterner<'db>>;

+

+interned_slice!(ConstsStorage, Consts, StoredConsts, consts, Const<'db>, Const<'static>);

+impl_foldable_for_interned_slice!(Consts);

+use std::{fmt, hash::Hash, num::NonZero};

+

+use intern::{Interned, InternedRef, impl_internable};

+use macros::{GenericTypeVisitable, TypeFoldable, TypeVisitable};

+use rustc_abi::{Size, TargetDataLayout};

+use rustc_type_ir::{GenericTypeVisitable, TypeFoldable, TypeVisitable, inherent::IntoKind};

+use stdx::never;

+

+use crate::{

+ MemoryMap, ParamEnvAndCrate, consteval,

+ mir::pad16,

+ next_solver::{Const, Consts, TyKind, WorldExposer},

+};

+

+use super::{DbInterner, Ty};

+

+pub type ValTreeKind<'db> = rustc_type_ir::ValTreeKind<DbInterner<'db>>;

+

+/// A type-level constant value.

+///

+/// Represents a typed, fully evaluated constant.

+#[derive(

+ Debug, Copy, Clone, Eq, PartialEq, Hash, TypeFoldable, TypeVisitable, GenericTypeVisitable,

+)]

+pub struct ValueConst<'db> {

+ pub ty: Ty<'db>,

+ pub value: ValTree<'db>,

+}

+

+impl<'db> ValueConst<'db> {

+ pub fn new(ty: Ty<'db>, kind: ValTreeKind<'db>) -> Self {

+ let value = ValTree::new(kind);

+ ValueConst { ty, value }

+ }

+}

+

+pub(super) fn allocation_to_const<'db>(

+ interner: DbInterner<'db>,

+ ty: Ty<'db>,

+ memory: &[u8],

+ memory_map: &MemoryMap<'db>,

+ param_env: ParamEnvAndCrate<'db>,

+) -> Const<'db> {

+ let Ok(data_layout) = interner.db.target_data_layout(param_env.krate) else {

+ return Const::error(interner);

+ };

+ let valtree = match ty.kind() {

+ TyKind::Bool => ValTreeKind::Leaf(ScalarInt::from(memory[0] != 0)),

+ TyKind::Char => {

+ let it = u128::from_le_bytes(pad16(memory, false)) as u32;

+ let Ok(c) = char::try_from(it) else {

+ return Const::error(interner);

+ };

+ ValTreeKind::Leaf(ScalarInt::from(c))

+ }

+ TyKind::Int(int) => {

+ let it = i128::from_le_bytes(pad16(memory, true));

+ let size = int.bit_width().map(Size::from_bits).unwrap_or(data_layout.pointer_size());

+ let scalar = ScalarInt::try_from_int(it, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ }

+ TyKind::Uint(uint) => {

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

+ let size = uint.bit_width().map(Size::from_bits).unwrap_or(data_layout.pointer_size());

+ let scalar = ScalarInt::try_from_uint(it, size).unwrap();

+ ValTreeKind::Leaf(scalar)

+ }

+ TyKind::Float(float) => {

+ let scalar = match float {

+ rustc_ast_ir::FloatTy::F16 => {

+ ScalarInt::from(u16::from_le_bytes(memory.try_into().unwrap()))

+ }

+ rustc_ast_ir::FloatTy::F32 => {

+ ScalarInt::from(u32::from_le_bytes(memory.try_into().unwrap()))

+ }

+ rustc_ast_ir::FloatTy::F64 => {

+ ScalarInt::from(u64::from_le_bytes(memory.try_into().unwrap()))

+ }

+ rustc_ast_ir::FloatTy::F128 => {

+ ScalarInt::from(u128::from_le_bytes(memory.try_into().unwrap()))

+ }

+ };

+ ValTreeKind::Leaf(scalar)

+ }

+ TyKind::Ref(_, t, _) => match t.kind() {

+ TyKind::Str => {

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

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

+ let Some(bytes) = memory_map.get(addr, size) else {

+ return Const::error(interner);

+ };

+ let u8_values = &interner.default_types().consts.u8_values;

+ ValTreeKind::Branch(Consts::new_from_iter(

+ interner,

+ bytes.iter().map(|&byte| u8_values[usize::from(byte)]),

+ ))

+ }

+ TyKind::Slice(ty) => {

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

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

+ let Ok(layout) = interner.db.layout_of_ty(ty.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let size_one = layout.size.bytes_usize();

+ let Some(bytes) = memory_map.get(addr, size_one * count) else {

+ return Const::error(interner);

+ };

+ let expected_len = count * size_one;

+ if bytes.len() < expected_len {

+ never!(

+ "Memory map size is too small. Expected {expected_len}, got {}",

+ bytes.len(),

+ );

+ return Const::error(interner);

+ }

+ let items = (0..count).map(|i| {

+ let offset = size_one * i;

+ let bytes = &bytes[offset..offset + size_one];

+ allocation_to_const(interner, ty, bytes, memory_map, param_env)

+ });

+ ValTreeKind::Branch(Consts::new_from_iter(interner, items))

+ }

+ TyKind::Dynamic(_, _) => {

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

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

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

+ return Const::error(interner);

+ };

+ let Ok(layout) = interner.db.layout_of_ty(t.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let size = layout.size.bytes_usize();

+ let Some(bytes) = memory_map.get(addr, size) else {

+ return Const::error(interner);

+ };

+ return allocation_to_const(interner, t, bytes, memory_map, param_env);

+ }

+ TyKind::Adt(..) if memory.len() == 2 * size_of::<usize>() => {

+ // FIXME: Unsized ADT.

+ return Const::error(interner);

+ }

+ _ => {

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

+ Ok(b) => b,

+ Err(_) => {

+ never!(

+ "tried rendering ty {:?} in const ref with incorrect byte count {}",

+ t,

+ memory.len()

+ );

+ return Const::error(interner);

+ }

+ });

+ let Ok(layout) = interner.db.layout_of_ty(t.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let size = layout.size.bytes_usize();

+ let Some(bytes) = memory_map.get(addr, size) else {

+ return Const::error(interner);

+ };

+ return allocation_to_const(interner, t, bytes, memory_map, param_env);

+ }

+ },

+ TyKind::Tuple(tys) => {

+ let Ok(layout) = interner.db.layout_of_ty(ty.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let items = tys.iter().enumerate().map(|(id, ty)| {

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

+ let Ok(layout) = interner.db.layout_of_ty(ty.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let size = layout.size.bytes_usize();

+ allocation_to_const(

+ interner,

+ ty,

+ &memory[offset..offset + size],

+ memory_map,

+ param_env,

+ )

+ });

+ ValTreeKind::Branch(Consts::new_from_iter(interner, items))

+ }

+ TyKind::Adt(..) => {

+ // FIXME: This requires `adt_const_params`.

+ return Const::error(interner);

+ }

+ TyKind::FnDef(..) => {

+ // FIXME: Fn items.

+ return Const::error(interner);

+ }

+ TyKind::FnPtr(_, _) | TyKind::RawPtr(_, _) => {

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

+ // FIXME: Unsized pointers.

+ let scalar = ScalarInt::try_from_uint(it, data_layout.pointer_size()).unwrap();

+ ValTreeKind::Leaf(scalar)

+ }

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

+ let Some(len) = consteval::try_const_usize(interner.db, len) else {

+ return Const::error(interner);

+ };

+ let Ok(layout) = interner.db.layout_of_ty(ty.store(), param_env.store()) else {

+ return Const::error(interner);

+ };

+ let size_one = layout.size.bytes_usize();

+ let items = (0..len as usize).map(|i| {

+ let offset = size_one * i;

+ allocation_to_const(

+ interner,

+ ty,

+ &memory[offset..offset + size_one],

+ memory_map,

+ param_env,

+ )

+ });

+ ValTreeKind::Branch(Consts::new_from_iter(interner, items))

+ }

+ TyKind::Never => return Const::error(interner),

+ // FIXME:

+ TyKind::Closure(_, _)

+ | TyKind::Coroutine(_, _)

+ | TyKind::CoroutineWitness(_, _)

+ | TyKind::CoroutineClosure(_, _)

+ | TyKind::UnsafeBinder(_) => return Const::error(interner),

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

+ TyKind::Foreign(_) => return Const::error(interner),

+ TyKind::Pat(_, _) => return Const::error(interner),

+ TyKind::Error(..)

+ | TyKind::Placeholder(_)

+ | TyKind::Alias(..)

+ | TyKind::Param(_)

+ | TyKind::Bound(_, _)

+ | TyKind::Infer(_) => return Const::error(interner),

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

+ TyKind::Slice(_) | TyKind::Str | TyKind::Dynamic(_, _) => {

+ return Const::error(interner);

+ }

+ };

+ Const::new_valtree(interner, ty, valtree)

+}

+

+impl<'db> rustc_type_ir::inherent::ValueConst<DbInterner<'db>> for ValueConst<'db> {

+ fn ty(self) -> Ty<'db> {

+ self.ty

+ }

+

+ fn valtree(self) -> ValTree<'db> {

+ self.value

+ }

+}

+

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

+pub struct ValTree<'db> {

+ interned: InternedRef<'db, ValTreeInterned>,

+}

+

+impl<'db, V: WorldExposer> GenericTypeVisitable<V> for ValTree<'db> {

+ fn generic_visit_with(&self, visitor: &mut V) {

+ if visitor.on_interned(self.interned).is_continue() {

+ self.inner().generic_visit_with(visitor);

+ }

+ }

+}

+

+impl<'db> TypeVisitable<DbInterner<'db>> for ValTree<'db> {

+ fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(

+ &self,

+ visitor: &mut V,

+ ) -> V::Result {

+ self.inner().visit_with(visitor)

+ }

+}

+

+impl<'db> TypeFoldable<DbInterner<'db>> for ValTree<'db> {

+ fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(

+ self,

+ folder: &mut F,

+ ) -> Result<Self, F::Error> {

+ self.inner().try_fold_with(folder).map(ValTree::new)

+ }

+

+ fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {

+ ValTree::new(self.inner().fold_with(folder))

+ }

+}

+

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

+pub(in super::super) struct ValTreeInterned(ValTreeKind<'static>);

+

+impl_internable!(gc; ValTreeInterned);

+

+const _: () = {

+ const fn is_copy<T: Copy>() {}

+ is_copy::<ValTree<'static>>();

+};

+

+impl<'db> IntoKind for ValTree<'db> {

+ type Kind = ValTreeKind<'db>;

+

+ fn kind(self) -> Self::Kind {

+ *self.inner()

+ }

+}

+

+impl<'db> ValTree<'db> {

+ #[inline]

+ pub fn new(kind: ValTreeKind<'db>) -> Self {

+ let kind = unsafe { std::mem::transmute::<ValTreeKind<'db>, ValTreeKind<'static>>(kind) };

+ Self { interned: Interned::new_gc(ValTreeInterned(kind)) }

+ }

+

+ #[inline]

+ pub fn inner(&self) -> &ValTreeKind<'db> {

+ let inner = &self.interned.0;

+ unsafe { std::mem::transmute::<&ValTreeKind<'static>, &ValTreeKind<'db>>(inner) }

+ }

+}

+

+impl std::fmt::Debug for ValTree<'_> {

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

+ self.interned.fmt(f)

+ }

+}

+

+/// The raw bytes of a simple value.

+///

+/// This is a packed struct in order to allow this type to be optimally embedded in enums

+/// (like Scalar).

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

+#[repr(Rust, packed)]

+pub struct ScalarInt {

+ /// The first `size` bytes of `data` are the value.

+ /// Do not try to read less or more bytes than that. The remaining bytes must be 0.

+ data: u128,

+ size: NonZero<u8>,

+}

+

+impl ScalarInt {

+ pub const TRUE: ScalarInt = ScalarInt { data: 1_u128, size: NonZero::new(1).unwrap() };

+ pub const FALSE: ScalarInt = ScalarInt { data: 0_u128, size: NonZero::new(1).unwrap() };

+

+ fn raw(data: u128, size: Size) -> Self {

+ Self { data, size: NonZero::new(size.bytes() as u8).unwrap() }

+ }

+

+ #[inline]

+ pub fn size(self) -> Size {

+ Size::from_bytes(self.size.get())

+ }

+

+ /// Make sure the `data` fits in `size`.

+ /// This is guaranteed by all constructors here, but having had this check saved us from

+ /// bugs many times in the past, so keeping it around is definitely worth it.

+ #[inline(always)]

+ fn check_data(self) {

+ // Using a block `{self.data}` here to force a copy instead of using `self.data`

+ // directly, because `debug_assert_eq` takes references to its arguments and formatting

+ // arguments and would thus borrow `self.data`. Since `Self`

+ // is a packed struct, that would create a possibly unaligned reference, which

+ // is UB.

+ debug_assert_eq!(

+ self.size().truncate(self.data),

+ { self.data },

+ "Scalar value {:#x} exceeds size of {} bytes",

+ { self.data },

+ self.size

+ );

+ }

+

+ #[inline]

+ pub fn null(size: Size) -> Self {

+ Self::raw(0, size)

+ }

+

+ #[inline]

+ pub fn is_null(self) -> bool {

+ self.data == 0

+ }

+

+ #[inline]

+ pub fn try_from_uint(i: impl Into<u128>, size: Size) -> Option<Self> {

+ let (r, overflow) = Self::truncate_from_uint(i, size);

+ if overflow { None } else { Some(r) }

+ }

+

+ /// Returns the truncated result, and whether truncation changed the value.

+ #[inline]

+ pub fn truncate_from_uint(i: impl Into<u128>, size: Size) -> (Self, bool) {

+ let data = i.into();

+ let r = Self::raw(size.truncate(data), size);

+ (r, r.data != data)

+ }

+

+ #[inline]

+ pub fn try_from_int(i: impl Into<i128>, size: Size) -> Option<Self> {

+ let (r, overflow) = Self::truncate_from_int(i, size);

+ if overflow { None } else { Some(r) }

+ }

+

+ /// Returns the truncated result, and whether truncation changed the value.

+ #[inline]

+ pub fn truncate_from_int(i: impl Into<i128>, size: Size) -> (Self, bool) {

+ let data = i.into();

+ // `into` performed sign extension, we have to truncate

+ let r = Self::raw(size.truncate(data as u128), size);

+ (r, size.sign_extend(r.data) != data)

+ }

+

+ #[inline]

+ pub fn try_from_target_usize(

+ i: impl Into<u128>,

+ data_layout: &TargetDataLayout,

+ ) -> Option<Self> {

+ Self::try_from_uint(i, data_layout.pointer_size())

+ }

+

+ /// Try to convert this ScalarInt to the raw underlying bits.

+ /// Fails if the size is wrong. Generally a wrong size should lead to a panic,

+ /// but Miri sometimes wants to be resilient to size mismatches,

+ /// so the interpreter will generally use this `try` method.

+ #[inline]

+ pub fn try_to_bits(self, target_size: Size) -> Result<u128, Size> {

+ assert_ne!(target_size.bytes(), 0, "you should never look at the bits of a ZST");

+ if target_size.bytes() == u64::from(self.size.get()) {

+ self.check_data();

+ Ok(self.data)

+ } else {

+ Err(self.size())

+ }

+ }

+

+ #[inline]

+ pub fn to_bits(self, target_size: Size) -> u128 {

+ self.try_to_bits(target_size).unwrap_or_else(|size| {

+ panic!("expected int of size {}, but got size {}", target_size.bytes(), size.bytes())

+ })

+ }

+

+ /// Extracts the bits from the scalar without checking the size.

+ #[inline]

+ pub fn to_bits_unchecked(self) -> u128 {

+ self.check_data();

+ self.data

+ }

+

+ /// Converts the `ScalarInt` to an unsigned integer of the given size.

+ /// Panics if the size of the `ScalarInt` is not equal to `size`.

+ #[inline]

+ pub fn to_uint(self, size: Size) -> u128 {

+ self.to_bits(size)

+ }

+

+ #[inline]

+ pub fn to_uint_unchecked(self) -> u128 {

+ self.data

+ }

+

+ /// Converts the `ScalarInt` to `u8`.

+ /// Panics if the `size` of the `ScalarInt`in not equal to 1 byte.

+ #[inline]

+ pub fn to_u8(self) -> u8 {

+ self.to_uint(Size::from_bits(8)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to `u16`.

+ /// Panics if the size of the `ScalarInt` in not equal to 2 bytes.

+ #[inline]

+ pub fn to_u16(self) -> u16 {

+ self.to_uint(Size::from_bits(16)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to `u32`.

+ /// Panics if the `size` of the `ScalarInt` in not equal to 4 bytes.

+ #[inline]

+ pub fn to_u32(self) -> u32 {

+ self.to_uint(Size::from_bits(32)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to `u64`.

+ /// Panics if the `size` of the `ScalarInt` in not equal to 8 bytes.

+ #[inline]

+ pub fn to_u64(self) -> u64 {

+ self.to_uint(Size::from_bits(64)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to `u128`.

+ /// Panics if the `size` of the `ScalarInt` in not equal to 16 bytes.

+ #[inline]

+ pub fn to_u128(self) -> u128 {

+ self.to_uint(Size::from_bits(128))

+ }

+

+ #[inline]

+ pub fn to_target_usize(&self, data_layout: &TargetDataLayout) -> u64 {

+ self.to_uint(data_layout.pointer_size()).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to `bool`.

+ /// Panics if the `size` of the `ScalarInt` is not equal to 1 byte.

+ /// Errors if it is not a valid `bool`.

+ #[inline]

+ pub fn try_to_bool(self) -> Result<bool, ()> {

+ match self.to_u8() {

+ 0 => Ok(false),

+ 1 => Ok(true),

+ _ => Err(()),

+ }

+ }

+

+ /// Converts the `ScalarInt` to a signed integer of the given size.

+ /// Panics if the size of the `ScalarInt` is not equal to `size`.

+ #[inline]

+ pub fn to_int(self, size: Size) -> i128 {

+ let b = self.to_bits(size);

+ size.sign_extend(b)

+ }

+

+ #[inline]

+ pub fn to_int_unchecked(self) -> i128 {

+ self.size().sign_extend(self.data)

+ }

+

+ /// Converts the `ScalarInt` to i8.

+ /// Panics if the size of the `ScalarInt` is not equal to 1 byte.

+ pub fn to_i8(self) -> i8 {

+ self.to_int(Size::from_bits(8)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to i16.

+ /// Panics if the size of the `ScalarInt` is not equal to 2 bytes.

+ pub fn to_i16(self) -> i16 {

+ self.to_int(Size::from_bits(16)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to i32.

+ /// Panics if the size of the `ScalarInt` is not equal to 4 bytes.

+ pub fn to_i32(self) -> i32 {

+ self.to_int(Size::from_bits(32)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to i64.

+ /// Panics if the size of the `ScalarInt` is not equal to 8 bytes.

+ pub fn to_i64(self) -> i64 {

+ self.to_int(Size::from_bits(64)).try_into().unwrap()

+ }

+

+ /// Converts the `ScalarInt` to i128.

+ /// Panics if the size of the `ScalarInt` is not equal to 16 bytes.

+ pub fn to_i128(self) -> i128 {

+ self.to_int(Size::from_bits(128))

+ }

+

+ #[inline]

+ pub fn to_target_isize(&self, data_layout: &TargetDataLayout) -> i64 {

+ self.to_int(data_layout.pointer_size()).try_into().unwrap()

+ }

+}

+

+macro_rules! from_x_for_scalar_int {

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

+ $(

+ impl From<$ty> for ScalarInt {

+ #[inline]

+ fn from(u: $ty) -> Self {

+ Self {

+ data: u128::from(u),

+ size: NonZero::new(size_of::<$ty>() as u8).unwrap(),

+ }

+ }

+ }

+ )*

+ }

+}

+

+macro_rules! from_scalar_int_for_x {

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

+ $(

+ impl From<ScalarInt> for $ty {

+ #[inline]

+ fn from(int: ScalarInt) -> Self {

+ // The `unwrap` cannot fail because to_uint (if it succeeds)

+ // is guaranteed to return a value that fits into the size.

+ int.to_uint(Size::from_bytes(size_of::<$ty>()))

+ .try_into().unwrap()

+ }

+ }

+ )*

+ }

+}

+

+from_x_for_scalar_int!(u8, u16, u32, u64, u128, bool);

+from_scalar_int_for_x!(u8, u16, u32, u64, u128);

+

+impl TryFrom<ScalarInt> for bool {

+ type Error = ();

+ #[inline]

+ fn try_from(int: ScalarInt) -> Result<Self, ()> {

+ int.try_to_bool()

+ }

+}

+

+impl From<char> for ScalarInt {

+ #[inline]

+ fn from(c: char) -> Self {

+ (c as u32).into()

+ }

+}

+

+macro_rules! from_x_for_scalar_int_signed {

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

+ $(

+ impl From<$ty> for ScalarInt {

+ #[inline]

+ fn from(u: $ty) -> Self {

+ Self {

+ data: u128::from(u.cast_unsigned()), // go via the unsigned type of the same size

+ size: NonZero::new(size_of::<$ty>() as u8).unwrap(),

+ }

+ }

+ }

+ )*

+ }

+}

+

+macro_rules! from_scalar_int_for_x_signed {

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

+ $(

+ impl From<ScalarInt> for $ty {

+ #[inline]

+ fn from(int: ScalarInt) -> Self {

+ // The `unwrap` cannot fail because to_int (if it succeeds)

+ // is guaranteed to return a value that fits into the size.

+ int.to_int(Size::from_bytes(size_of::<$ty>()))

+ .try_into().unwrap()

+ }

+ }

+ )*

+ }

+}

+

+from_x_for_scalar_int_signed!(i8, i16, i32, i64, i128);

+from_scalar_int_for_x_signed!(i8, i16, i32, i64, i128);

+

+impl From<std::cmp::Ordering> for ScalarInt {

+ #[inline]

+ fn from(c: std::cmp::Ordering) -> Self {

+ // Here we rely on `cmp::Ordering` having the same values in host and target!

+ ScalarInt::from(c as i8)

+ }

+}

+

+/// Error returned when a conversion from ScalarInt to char fails.

+#[derive(Debug)]

+pub struct CharTryFromScalarInt;

+

+impl TryFrom<ScalarInt> for char {

+ type Error = CharTryFromScalarInt;

+

+ #[inline]

+ fn try_from(int: ScalarInt) -> Result<Self, Self::Error> {

+ match char::from_u32(int.to_u32()) {

+ Some(c) => Ok(c),

+ None => Err(CharTryFromScalarInt),

+ }

+ }

+}

+

+impl fmt::Debug for ScalarInt {

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

+ // Dispatch to LowerHex below.

+ write!(f, "0x{self:x}")

+ }

+}

+

+impl fmt::LowerHex for ScalarInt {

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

+ self.check_data();

+ if f.alternate() {

+ // Like regular ints, alternate flag adds leading `0x`.

+ write!(f, "0x")?;

+ }

+ // Format as hex number wide enough to fit any value of the given `size`.

+ // So data=20, size=1 will be "0x14", but with size=4 it'll be "0x00000014".

+ // Using a block `{self.data}` here to force a copy instead of using `self.data`

+ // directly, because `write!` takes references to its formatting arguments and

+ // would thus borrow `self.data`. Since `Self`

+ // is a packed struct, that would create a possibly unaligned reference, which

+ // is UB.

+ write!(f, "{:01$x}", { self.data }, self.size.get() as usize * 2)

+ }

+}

+

+impl fmt::UpperHex for ScalarInt {

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

+ self.check_data();

+ // Format as hex number wide enough to fit any value of the given `size`.

+ // So data=20, size=1 will be "0x14", but with size=4 it'll be "0x00000014".

+ // Using a block `{self.data}` here to force a copy instead of using `self.data`

+ // directly, because `write!` takes references to its formatting arguments and

+ // would thus borrow `self.data`. Since `Self`

+ // is a packed struct, that would create a possibly unaligned reference, which

+ // is UB.

+ write!(f, "{:01$X}", { self.data }, self.size.get() as usize * 2)

+ }

+}

+

+impl fmt::Display for ScalarInt {

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

+ self.check_data();

+ write!(f, "{}", { self.data })

+ }

+}

+ fn replace_region(&mut self, br: BoundRegion<'db>) -> Region<'db>;

+ fn replace_ty(&mut self, bt: BoundTy<'db>) -> Ty<'db>;

+ fn replace_const(&mut self, bv: BoundConst<'db>) -> Const<'db>;

+ pub regions: &'a mut (dyn FnMut(BoundRegion<'db>) -> Region<'db> + 'a),

+ pub types: &'a mut (dyn FnMut(BoundTy<'db>) -> Ty<'db> + 'a),

+ pub consts: &'a mut (dyn FnMut(BoundConst<'db>) -> Const<'db> + 'a),

+ fn replace_region(&mut self, br: BoundRegion<'db>) -> Region<'db> {

+ fn replace_ty(&mut self, bt: BoundTy<'db>) -> Ty<'db> {

+ fn replace_const(&mut self, bv: BoundConst<'db>) -> Const<'db> {

+ ) -> (T, FxIndexMap<BoundRegion<'db>, Region<'db>>)

+ F: FnMut(BoundRegion<'db>) -> Region<'db>,

+ let real_fld_r = |br: BoundRegion<'db>| *region_map.entry(br).or_insert_with(|| fld_r(br));

+ F: FnMut(BoundRegion<'db>) -> Region<'db>,

+ Binder, Canonical, CanonicalVarKind, CanonicalVarKinds, Const, ConstKind, DbInterner,

+ GenericArg, PlaceholderConst, PlaceholderRegion, Region, Ty, TyKind,

+use crate::next_solver::{PlaceholderType, infer::InferCtxt};

+ var_kinds: CanonicalVarKinds::empty(tcx),

+ variables: SmallVec::from_slice(base.var_kinds.as_slice()),

+ CanonicalVarKinds::new_from_slice(&canonicalizer.universe_canonicalized_variables());

+ Canonical { max_universe, var_kinds: canonical_variables, value: (base.value, out_value) }

+ CanonicalVarKind::PlaceholderTy(PlaceholderType::new(

+ reverse_universe_map[&placeholder.universe],

+ placeholder.bound,

+ ))

+ CanonicalVarKind::PlaceholderRegion(PlaceholderRegion::new(

+ reverse_universe_map[&placeholder.universe],

+ placeholder.bound,

+ ))

+ CanonicalVarKind::PlaceholderConst(PlaceholderConst::new(

+ reverse_universe_map[&placeholder.universe],

+ placeholder.bound,

+ ))

+ assert_eq!(self.var_kinds.len(), var_values.len());

+ regions: &mut |br: BoundRegion<'db>| match var_values[br.var].kind() {

+ types: &mut |bound_ty: BoundTy<'db>| match var_values[bound_ty.var].kind() {

+ consts: &mut |bound_ct: BoundConst<'db>| match var_values[bound_ct.var].kind() {

+ IndexVec::from_elem_n(None, query_response.var_kinds.len());

+ query_response.var_kinds.as_slice()[b.var.as_usize()],

+ let variables = query_response.var_kinds;

+ OpaqueTypeKey, PlaceholderConst, PlaceholderRegion, PlaceholderType, Region, Ty, TyKind,

+ canonical.var_kinds,

+ CanonicalVarKind::PlaceholderTy(PlaceholderType { universe, bound, .. }) => {

+ let placeholder_mapped = PlaceholderType::new(universe_mapped, bound);

+ CanonicalVarKind::PlaceholderRegion(PlaceholderRegion { universe, bound, .. }) => {

+ let placeholder_mapped = PlaceholderRegion::new(universe_mapped, bound);

+ CanonicalVarKind::PlaceholderConst(PlaceholderConst { universe, bound, .. }) => {

+ let placeholder_mapped = PlaceholderConst::new(universe_mapped, bound);

+ ArgOutlivesPredicate, BoundConst, BoundRegion, BoundTy, BoundVariableKind, Goal, Predicate,

+pub mod select;

+ let infcx = self.build(input.typing_mode.0);

+ BoundVariableKind::Ty(_) => self.next_ty_var().into(),

+ BoundVariableKind::Region(_) => self.next_region_var().into(),

+ BoundVariableKind::Const => self.next_const_var().into(),

+ fn replace_region(&mut self, br: BoundRegion<'db>) -> Region<'db> {

+ fn replace_ty(&mut self, bt: BoundTy<'db>) -> Ty<'db> {

+ fn replace_const(&mut self, bv: BoundConst<'db>) -> Const<'db> {

+use crate::next_solver::{AliasTy, Binder, DbInterner, ParamTy, PlaceholderType, Region, Ty};

+ Placeholder(PlaceholderType<'db>),

+ TyKind::Alias(data) => match self.structurally_relate_aliases {

+ PlaceholderRegion, PlaceholderType, Region, Ty,

+ regions: &mut |br: BoundRegion<'db>| {

+ Region::new_placeholder(self.interner, PlaceholderRegion::new(next_universe, br))

+ types: &mut |bound_ty: BoundTy<'db>| {

+ Ty::new_placeholder(self.interner, PlaceholderType::new(next_universe, bound_ty))

+ consts: &mut |bound: BoundConst<'db>| {

+ Const::new_placeholder(self.interner, PlaceholderConst::new(next_universe, bound))

+ TyKind::Alias(AliasTy { kind: rustc_type_ir::Opaque { def_id: a_def_id }, .. }),

+ TyKind::Alias(AliasTy { kind: rustc_type_ir::Opaque { def_id: b_def_id }, .. }),

+ AliasTermKind, AliasTy, AliasTyKind, BoundVar, CoroutineWitnessTypes, DebruijnIndex,

+ EarlyBinder, FlagComputation, Flags, GenericArgKind, GenericTypeVisitable, ImplPolarity,

+ InferTy, Interner, TraitRef, TypeFlags, TypeVisitableExt, Upcast, Variance,

+ Consts, CoroutineClosureIdWrapper, CoroutineIdWrapper, Ctor, FnSig, FxIndexMap,

+ GeneralConstIdWrapper, LateParamRegion, OpaqueTypeKey, RegionAssumptions, ScalarInt,

+ SimplifiedType, SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper,

+ UnevaluatedConst,

+ ParamTy, PredefinedOpaques, Predicate, SolverDefId, Term, Ty, TyKind, Tys, ValTree, ValueConst,

+ region::{BoundRegion, BoundRegionKind, EarlyParamRegion, Region},

+

+ #[inline]

+ pub(crate) fn expect_crate(&self) -> Crate {

+ self.krate.expect("should have a crate")

+ }

+ BoundVariableKind<'db>,

+ BoundVariableKind<'static>,

+pub type BoundVariableKind<'db> = rustc_type_ir::BoundVariableKind<DbInterner<'db>>;

+ CanonicalVarKinds,

+

+ fn is_packed(self) -> bool {

+ self.repr().packed()

+ }

+

+ fn field_representing_type_info(

+ self,

+ _interner: DbInterner<'db>,

+ _args: GenericArgs<'db>,

+ ) -> Option<rustc_type_ir::FieldInfo<DbInterner<'db>>> {

+ // FIXME

+ None

+ }

+ fn feature_bound_holds_in_crate(self, _symbol: Symbol) -> bool {

+}

+

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

+pub struct Symbol;

+impl<'db> inherent::Symbol<DbInterner<'db>> for Symbol {

+ fn is_kw_underscore_lifetime(self) -> bool {

+ type CanonicalVarKinds = CanonicalVarKinds<'db>;

+ CanonicalVarKinds::new_from_slice(kinds)

+ type Symbol = Symbol;

+ type ValTree = ValTree<'db>;

+ type Consts = Consts<'db>;

+ type ScalarInt = ScalarInt;

+ type LateParamRegion = LateParamRegion<'db>;

+ fn features(self) -> Features {

+ if let TyKind::Alias(alias @ AliasTy { kind: AliasTyKind::Projection { .. }, .. }) =

+ ty.kind()

+ {

+ SolverLangItem::FieldBase => unimplemented!(),

+ SolverLangItem::FieldType => unimplemented!(),

+ SolverTraitLangItem::Field => unimplemented!(),

+ Field,

+ FieldBase,

+ FieldType,

+ FieldBase,

+ FieldType,

+ Field,

+ TyKind::Alias(..) | TyKind::Placeholder(..) | TyKind::Error(_) => (),

+ map: &'a mut FxIndexMap<BoundVar, BoundVariableKind<'db>>,

+ fn replace_region(&mut self, br: BoundRegion<'db>) -> Region<'db> {

+ let kind = (*entry

+ .or_insert_with(|| BoundVariableKind::Region(BoundRegionKind::Anon)))

+ .expect_region();

+ fn replace_ty(&mut self, bt: BoundTy<'db>) -> Ty<'db> {

+ let kind = (*entry.or_insert_with(|| BoundVariableKind::Ty(BoundTyKind::Anon)))

+ .expect_ty();

+ fn replace_const(&mut self, bv: BoundConst<'db>) -> Const<'db> {

+ let () = (*entry.or_insert_with(|| BoundVariableKind::Const)).expect_const();

+ Const::new_bound(self.interner, DebruijnIndex::ZERO, BoundConst::new(var))

+

+ fn anon_const_kind(self, _def_id: Self::DefId) -> rustc_type_ir::AnonConstKind {

+ // FIXME

+ rustc_type_ir::AnonConstKind::GCE

+ }

+

+ fn alias_ty_kind_from_def_id(self, def_id: Self::DefId) -> AliasTyKind<DbInterner<'db>> {

+ match def_id {

+ SolverDefId::TypeAliasId(type_alias) => match type_alias.loc(self.db).container {

+ ItemContainerId::ExternBlockId(_) | ItemContainerId::ModuleId(_) => {

+ AliasTyKind::Free { def_id }

+ }

+ ItemContainerId::ImplId(_) => AliasTyKind::Inherent { def_id },

+ ItemContainerId::TraitId(_) => AliasTyKind::Projection { def_id },

+ },

+ SolverDefId::InternedOpaqueTyId(_) => AliasTyKind::Opaque { def_id },

+ _ => unreachable!(),

+ }

+ }

+

+ fn closure_is_const(self, _def_id: Self::ClosureId) -> bool {

+ // FIXME

+ false

+ }

+

+ fn item_name(self, _item_index: Self::DefId) -> Self::Symbol {

+ Symbol

+ }

+ regions: &mut |r: BoundRegion<'db>| {

+ types: &mut |t: BoundTy<'db>| {

+ Const::new_bound(self, DebruijnIndex::ZERO, BoundConst::new(shift_bv(c.var)))

+ ScalarInt,

+ gc.add_storage::<super::consts::ValTreeInterned>();

+ gc.add_storage::<super::allocation::AllocationInterned>();

+ gc.add_slice_storage::<super::consts::ConstsStorage>();

+ super::consts::ValTreeInterned,

+ super::allocation::AllocationInterned,

+ super::consts::ConstsStorage,

+ crate::with_attached_db(|db| match t.kind.def_id() {

+#[expect(dead_code, reason = "rustc has this")]

+use intern::{Interned, InternedRef, impl_internable};

+ BoundVarIndexKind, DebruijnIndex, Flags, GenericTypeVisitable, INNERMOST, RegionVid, TypeFlags,

+ TypeFoldable, TypeVisitable,

+ inherent::{IntoKind, SliceLike},

+use super::{SolverDefId, interner::DbInterner};

+ pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderRegion<'db>) -> Self {

+ bound: BoundRegion<'db>,

+pub type PlaceholderRegion<'db> = rustc_type_ir::PlaceholderRegion<DbInterner<'db>>;

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

+pub struct LateParamRegion<'db> {

+ pub bound_region: BoundRegionKind<'db>,

+impl std::fmt::Debug for LateParamRegion<'_> {

+pub type BoundRegion<'db> = rustc_type_ir::BoundRegion<DbInterner<'db>>;

+pub type BoundRegionKind<'db> = rustc_type_ir::BoundRegionKind<DbInterner<'db>>;

+ debruijn: DebruijnIndex,

+ var: BoundRegion<'db>,

+ debruijn: DebruijnIndex,

+ fn new_placeholder(interner: DbInterner<'db>, var: PlaceholderRegion<'db>) -> Self {

+use crate::{

+ ParamEnvAndCrate,

+ next_solver::{

+ AliasTy, AnyImplId, CanonicalVarKind, Clause, ClauseKind, CoercePredicate, GenericArgs,

+ ParamEnv, Predicate, PredicateKind, SubtypePredicate, Ty, TyKind, UnevaluatedConst,

+ fold::fold_tys, util::sizedness_fast_path,

+ },

+ TyKind::Alias(AliasTy {

+ kind: AliasTyKind::Opaque { def_id: def_id2 },

+ args: args2,

+ ..

+ }) if def_id == def_id2 && args == args2 => hidden_ty,

+ param_env: ParamEnv<'db>,

+ uv: UnevaluatedConst<'db>,

+ ) -> Option<Const<'db>> {

+ let ec = match uv.def.0 {

+ self.cx().db.const_eval(c, subst, None).ok()?

+ GeneralConstId::StaticId(c) => self.cx().db.const_eval_static(c).ok()?,

+ GeneralConstId::AnonConstId(_) => return Some(Const::error(self.cx())),

+ };

+ Some(Const::new_from_allocation(

+ self.interner,

+ &ec,

+ ParamEnvAndCrate { param_env, krate: self.interner.expect_crate() },

+ ))

+ AdtDef as _, BoundExistentialPredicates, Const as _, GenericArgs as _, IntoKind, ParamLike,

+ Safety as _, SliceLike, Ty as _,

+ DbInterner, GenericArgs, SolverDefId,

+ pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderType<'db>) -> Self {

+ Ty::new_alias(

+ interner,

+ AliasTy::new_from_args(interner, AliasTyKind::Opaque { def_id }, args),

+ )

+ TyKind::Alias(AliasTy { kind: AliasTyKind::Opaque { def_id }, args, .. }) => Some(

+ def_id

+ .iter_instantiated_copied(interner, args.as_slice())

+ (TyKind::Alias(alias), TyKind::Alias(alias2)) => alias.kind == alias2.kind,

+ TyKind::Alias(ref data) => data.visit_with(visitor),

+ TyKind::Alias(data) => TyKind::Alias(data.try_fold_with(folder)?),

+ TyKind::Alias(data) => TyKind::Alias(data.fold_with(folder)),

+ fn new_placeholder(interner: DbInterner<'db>, param: PlaceholderType<'db>) -> Self {

+ fn new_bound(interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundTy<'db>) -> Self {

+ fn new_alias(interner: DbInterner<'db>, alias_ty: AliasTy<'db>) -> Self {

+ Ty::new(interner, TyKind::Alias(alias_ty))

+pub type PlaceholderType<'db> = rustc_type_ir::PlaceholderType<DbInterner<'db>>;

+pub type BoundTy<'db> = rustc_type_ir::BoundTy<DbInterner<'db>>;

+pub type BoundTyKind<'db> = rustc_type_ir::BoundTyKind<DbInterner<'db>>;

+ BoundConst, FxIndexMap, ParamEnv, PlaceholderConst, PlaceholderRegion, PlaceholderType,

+ let types = &mut |ty: BoundTy<'db>| args.as_slice()[ty.var.index()].expect_ty();

+ let regions =

+ &mut |region: BoundRegion<'db>| args.as_slice()[region.var.index()].expect_region();

+ let consts = &mut |const_: BoundConst<'db>| args.as_slice()[const_.var.index()].expect_const();

+ mapped_regions: FxIndexMap<PlaceholderRegion<'db>, BoundRegion<'db>>,

+ mapped_types: FxIndexMap<PlaceholderType<'db>, BoundTy<'db>>,

+ mapped_consts: FxIndexMap<PlaceholderConst<'db>, BoundConst<'db>>,

+ mapped_regions: FxIndexMap<PlaceholderRegion<'db>, BoundRegion<'db>>,

+ mapped_types: FxIndexMap<PlaceholderType<'db>, BoundTy<'db>>,

+ mapped_consts: FxIndexMap<PlaceholderConst<'db>, BoundConst<'db>>,

+ TyKind::Alias(alias) => {

+ allocation: it,

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

+ format!("{}", self.allocation.display(db, display_target))

+ let ty = self.allocation.ty.kind();

+ if let TyKind::Int(_) | TyKind::Uint(_) = ty {

+ let b = &self.allocation.memory;

+ mir::render_const_using_debug_impl(db, self.def, self.allocation, self.ty)

+ allocation: it,

+ AliasTy::new_from_args(

+ interner,

+ AliasTyKind::Projection { def_id: alias.id.into() },

+ args,

+ ),

+ let TyKind::Alias(AliasTy { kind: AliasTyKind::Projection { def_id }, .. }) =

+ self.ty.kind()

+ else {

+ return None;

+ };

+ match def_id.expect_type_alias().loc(db).container {

+ layout::FieldsShape::Arbitrary { ref offsets, ref in_memory_order } => {

+ let tail = in_memory_order[in_memory_order.len().checked_sub(1)? as u32];

+ layout::FieldsShape::Arbitrary { ref offsets, ref in_memory_order } => {

+ let mut reverse_index = vec![None; in_memory_order.len()];

+ for (mem, src) in in_memory_order.iter().enumerate() {

+ reverse_index[mem] =

+ Some((src.0.into_raw().into_u32() as usize, offsets[*src].bytes()));

+ AliasTy, DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, Ty, TyKind, TypingMode,

+ TyKind::Alias(AliasTy {

+ kind: AliasTyKind::Projection { def_id },

+ args,

+ ..

+ }) => {

+ let assoc_id = def_id.expect_type_alias();

+ GenericSubstitution::new(assoc_id.into(), args, env),