+// FIXME: We used to import `rustc_*` deps from `rustc_private` with `feature = "in-rust-tree" but

+// temporarily switched to crates.io versions due to hardships that working on them from rustc

+// demands corresponding changes on rust-analyzer at the same time.

+// For details, see the zulip discussion below:

+// https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/relying.20on.20in-tree.20.60rustc_type_ir.60.2F.60rustc_next_trait_solver.60/with/541055689

+extern crate ra_ap_rustc_ast_ir as rustc_ast_ir;

+

+extern crate ra_ap_rustc_type_ir as rustc_type_ir;

+

+extern crate ra_ap_rustc_next_trait_solver as rustc_next_trait_solver;

+

+extern crate self as hir_ty;

+

+pub mod next_solver;

+mod specialization;

+pub mod drop;

+use hir_def::{CallableDefId, TypeOrConstParamId, type_ref::Rawness};

+use rustc_type_ir::{

+ BoundVarIndexKind, TypeSuperVisitable, TypeVisitableExt, UpcastFrom,

+ inherent::{IntoKind, SliceLike, Ty as _},

+};

+ next_solver::{

+ AliasTy, Binder, BoundConst, BoundRegion, BoundRegionKind, BoundTy, BoundTyKind, Canonical,

+ CanonicalVarKind, CanonicalVars, Const, ConstKind, DbInterner, FnSig, PolyFnSig, Predicate,

+ Region, RegionKind, TraitRef, Ty, TyKind, Tys, abi,

+ },

+ closure::analysis::{CaptureKind, CapturedItem},

+ LifetimeElisionKind, TyDefId, TyLoweringContext, ValueTyDefId,

+ associated_type_shorthand_candidates, diagnostics::*,

+pub use next_solver::interner::{attach_db, attach_db_allow_change, with_attached_db};

+pub use utils::{

+ TargetFeatureIsSafeInTarget, Unsafety, all_super_traits, direct_super_traits,

+ is_fn_unsafe_to_call, target_feature_is_safe_in_target,

+pub enum MemoryMap<'db> {

+ Complex(Box<ComplexMemoryMap<'db>>),

+pub struct ComplexMemoryMap<'db> {

+ vtable: VTableMap<'db>,

+impl ComplexMemoryMap<'_> {

+impl<'db> MemoryMap<'db> {

+ pub fn vtable_ty(&self, id: usize) -> Result<Ty<'db>, MirEvalError<'db>> {

+ mut f: impl FnMut(&[u8], usize) -> Result<usize, MirEvalError<'db>>,

+ ) -> Result<FxHashMap<usize, usize>, MirEvalError<'db>> {

+pub enum ImplTraitId<'db> {

+ ReturnTypeImplTrait(hir_def::FunctionId, next_solver::ImplTraitIdx<'db>),

+ TypeAliasImplTrait(hir_def::TypeAliasId, next_solver::ImplTraitIdx<'db>),

+pub fn replace_errors_with_variables<'db, T>(interner: DbInterner<'db>, t: &T) -> Canonical<'db, T>

+ T: rustc_type_ir::TypeFoldable<DbInterner<'db>> + Clone,

+ use rustc_type_ir::{FallibleTypeFolder, TypeSuperFoldable};

+ struct ErrorReplacer<'db> {

+ interner: DbInterner<'db>,

+ vars: Vec<CanonicalVarKind<'db>>,

+ binder: rustc_type_ir::DebruijnIndex,

+ impl<'db> FallibleTypeFolder<DbInterner<'db>> for ErrorReplacer<'db> {

+ #[cfg(debug_assertions)]

+ type Error = ();

+ #[cfg(not(debug_assertions))]

+ type Error = std::convert::Infallible;

+

+ fn cx(&self) -> DbInterner<'db> {

+ self.interner

+ }

+

+ fn try_fold_binder<T>(&mut self, t: Binder<'db, T>) -> Result<Binder<'db, T>, Self::Error>

+ where

+ T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,

+ {

+ self.binder.shift_in(1);

+ let result = t.try_super_fold_with(self);

+ self.binder.shift_out(1);

+ result

+ }

+

+ fn try_fold_ty(&mut self, t: Ty<'db>) -> Result<Ty<'db>, Self::Error> {

+ if !t.has_type_flags(

+ rustc_type_ir::TypeFlags::HAS_ERROR

+ | rustc_type_ir::TypeFlags::HAS_TY_INFER

+ | rustc_type_ir::TypeFlags::HAS_CT_INFER

+ | rustc_type_ir::TypeFlags::HAS_RE_INFER,

+ ) {

+ return Ok(t);

+ #[cfg(debug_assertions)]

+ let error = || Err(());

+ #[cfg(not(debug_assertions))]

+ let error = || Ok(Ty::new_error(self.interner, crate::next_solver::ErrorGuaranteed));

+

+ match t.kind() {

+ TyKind::Error(_) => {

+ let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

+ self.vars.push(CanonicalVarKind::Ty {

+ ui: rustc_type_ir::UniverseIndex::ZERO,

+ sub_root: var,

+ });

+ Ok(Ty::new_bound(

+ self.interner,

+ self.binder,

+ BoundTy { var, kind: BoundTyKind::Anon },

+ ))

+ }

+ TyKind::Infer(_) => error(),

+ TyKind::Bound(BoundVarIndexKind::Bound(index), _) if index > self.binder => error(),

+ _ => t.try_super_fold_with(self),

+ fn try_fold_const(&mut self, ct: Const<'db>) -> Result<Const<'db>, Self::Error> {

+ if !ct.has_type_flags(

+ rustc_type_ir::TypeFlags::HAS_ERROR

+ | rustc_type_ir::TypeFlags::HAS_TY_INFER

+ | rustc_type_ir::TypeFlags::HAS_CT_INFER

+ | rustc_type_ir::TypeFlags::HAS_RE_INFER,

+ ) {

+ return Ok(ct);

+ #[cfg(debug_assertions)]

+ let error = || Err(());

+ #[cfg(not(debug_assertions))]

+ let error = || Ok(Const::error(self.interner));

+ match ct.kind() {

+ ConstKind::Error(_) => {

+ let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

+ self.vars.push(CanonicalVarKind::Const(rustc_type_ir::UniverseIndex::ZERO));

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

+ }

+ ConstKind::Infer(_) => error(),

+ ConstKind::Bound(BoundVarIndexKind::Bound(index), _) if index > self.binder => {

+ error()

+ }

+ _ => ct.try_super_fold_with(self),

+ }

+ fn try_fold_region(&mut self, region: Region<'db>) -> Result<Region<'db>, Self::Error> {

+ #[cfg(debug_assertions)]

+ let error = || Err(());

+ #[cfg(not(debug_assertions))]

+ let error = || Ok(Region::error(self.interner));

+

+ match region.kind() {

+ RegionKind::ReError(_) => {

+ let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

+ self.vars.push(CanonicalVarKind::Region(rustc_type_ir::UniverseIndex::ZERO));

+ Ok(Region::new_bound(

+ self.interner,

+ self.binder,

+ BoundRegion { var, kind: BoundRegionKind::Anon },

+ ))

+ }

+ RegionKind::ReVar(_) => error(),

+ RegionKind::ReBound(BoundVarIndexKind::Bound(index), _) if index > self.binder => {

+ error()

+ }

+ _ => Ok(region),

+ }

+

+ let mut error_replacer =

+ ErrorReplacer { vars: Vec::new(), binder: rustc_type_ir::DebruijnIndex::ZERO, interner };

+ let value = match t.clone().try_fold_with(&mut error_replacer) {

+ Canonical {

+ value,

+ max_universe: rustc_type_ir::UniverseIndex::ZERO,

+ variables: CanonicalVars::new_from_iter(interner, error_replacer.vars),

+ }

+pub fn callable_sig_from_fn_trait<'db>(

+ self_ty: Ty<'db>,

+ trait_env: Arc<TraitEnvironment<'db>>,

+ db: &'db dyn HirDatabase,

+) -> Option<(FnTrait, PolyFnSig<'db>)> {

+ let args_ty = table.next_ty_var();

+ let args = [self_ty, args_ty];

+ let trait_ref = TraitRef::new(table.interner(), fn_once_trait.into(), args);

+ let projection = Ty::new_alias(

+ table.interner(),

+ rustc_type_ir::AliasTyKind::Projection,

+ AliasTy::new(table.interner(), output_assoc_type.into(), args),

+ );

+

+ let pred = Predicate::upcast_from(trait_ref, table.interner());

+ if !table.try_obligation(pred).no_solution() {

+ table.register_obligation(pred);

+ let return_ty = table.normalize_alias_ty(projection);

+ let trait_ref = TraitRef::new(table.interner(), fn_x_trait.into(), args);

+ if !table

+ .try_obligation(Predicate::upcast_from(trait_ref, table.interner()))

+ .no_solution()

+ {

+ let TyKind::Tuple(params) = args_ty.kind() else {

+ return None;

+ };

+ let inputs_and_output = Tys::new_from_iter(

+ table.interner(),

+ params.iter().chain(std::iter::once(ret_ty)),

+ );

+ Binder::dummy(FnSig {

+ inputs_and_output,

+ c_variadic: false,

+ safety: abi::Safety::Safe,

+ abi: FnAbi::RustCall,

+ }),

+struct ParamCollector {

+ params: FxHashSet<TypeOrConstParamId>,

+impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for ParamCollector {

+ type Result = ();

+ fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {

+ if let TyKind::Param(param) = ty.kind() {

+ self.params.insert(param.id.into());

+ ty.super_visit_with(self);

+ fn visit_const(&mut self, konst: Const<'db>) -> Self::Result {

+ if let ConstKind::Param(param) = konst.kind() {

+ self.params.insert(param.id.into());

+

+ konst.super_visit_with(self);

+/// Returns unique params for types and consts contained in `value`.

+pub fn collect_params<'db, T>(value: &T) -> Vec<TypeOrConstParamId>

+ T: ?Sized + rustc_type_ir::TypeVisitable<DbInterner<'db>>,

+ let mut collector = ParamCollector { params: FxHashSet::default() };

+ value.visit_with(&mut collector);

+ Vec::from_iter(collector.params)

+pub fn known_const_to_ast<'db>(

+ konst: Const<'db>,

+ db: &'db dyn HirDatabase,

+

+pub fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> {

+ use std::env;

+ use std::sync::LazyLock;

+ use tracing_subscriber::{Registry, layer::SubscriberExt};

+ use tracing_tree::HierarchicalLayer;

+

+ static ENABLE: LazyLock<bool> = LazyLock::new(|| env::var("CHALK_DEBUG").is_ok());

+ if !*ENABLE {

+ return None;

+ }

+

+ let filter: tracing_subscriber::filter::Targets =

+ env::var("CHALK_DEBUG").ok().and_then(|it| it.parse().ok()).unwrap_or_default();

+ let layer = HierarchicalLayer::default()

+ .with_indent_lines(true)

+ .with_ansi(false)

+ .with_indent_amount(2)

+ .with_writer(std::io::stderr);

+ let subscriber = Registry::default().with(filter).with(layer);

+ Some(tracing::subscriber::set_default(subscriber))

+}