+// 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;

+

+mod lower_nextsolver;

+pub mod next_solver;

+pub mod consteval_nextsolver;

+ NoSolution, VariableKinds,

+use rustc_type_ir::inherent::SliceLike;

+ next_solver::{

+ DbInterner,

+ mapping::{ChalkToNextSolver, convert_ty_for_result},

+ },

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

+ ValueTyDefId, diagnostics::*,

+pub use lower_nextsolver::associated_type_shorthand_candidates;

+ to_foreign_def_id, to_placeholder_idx, to_placeholder_idx_no_index,

+pub use utils::{

+ TargetFeatureIsSafeInTarget, Unsafety, all_super_traits, direct_super_traits,

+ is_fn_unsafe_to_call, target_feature_is_safe_in_target,

+};

+

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

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

+pub(crate) use chalk_ir::FnSubst; // a re-export so we don't lose the tuple constructor

+

+pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;

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

+pub(crate) type InferenceVar = chalk_ir::InferenceVar;

+

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

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

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

+pub type Const = chalk_ir::Const<Interner>;

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

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

+

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

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

+

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

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

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

+

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

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

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

+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<crate::next_solver::Ty<'db>, MirEvalError> {

+// FIXME(next-solver): add a lifetime to this

+ Bytes(Box<[u8]>, MemoryMap<'static>),

+/// A concrete constant value

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

+pub enum ConstScalarNs<'db> {

+ Bytes(Box<[u8]>, MemoryMap<'db>),

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

+ // constants

+ UnevaluatedConst(GeneralConstId, Substitution),

+ /// Case of an unknown value that rustc might know but we don't

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

+ // constants

+ // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177

+ // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348

+ Unknown,

+}

+

+impl Hash for ConstScalarNs<'_> {

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

+ core::mem::discriminant(self).hash(state);

+ if let ConstScalarNs::Bytes(b, _) = self {

+ b.hash(state)

+ }

+ }

+}

+

+ chalk_ir::VariableKinds::from_iter(

+) -> VariableKinds<Interner> {

+ pub fn from_fn_sig_and_header<'db>(

+ interner: DbInterner<'db>,

+ sig: crate::next_solver::Binder<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>,

+ header: rustc_type_ir::FnHeader<DbInterner<'db>>,

+ ) -> CallableSig {

+ CallableSig {

+ // FIXME: what to do about lifetime params? -> return PolyFnSig

+ params_and_return: Arc::from_iter(

+ sig.skip_binder()

+ .inputs_and_output

+ .iter()

+ .map(|t| convert_ty_for_result(interner, t)),

+ ),

+ is_varargs: header.c_variadic,

+ safety: match header.safety {

+ next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,

+ next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,

+ },

+ abi: header.abi,

+ }

+ }

+ let goal: Goal = trait_ref.clone().cast(Interner);

+ let pred = goal.to_nextsolver(table.interner);

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

+ table.register_obligation(pred);

+ if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {

+ let id = from_placeholder_idx(self.db, idx).0;

+ let chalk_ir::TyData { kind, flags } = ty.data(Interner);

+

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

+}