use std::fmt;

use base_db::Crate;

use rustc_hash::FxHashSet;

use rustc_type_ir::{

inherent::{Const as _, GenericArg as _, IntoKind, Ty as _},

solve::Certainty,

};

use smallvec::SmallVec;

use crate::{

db::HirDatabase,

next_solver::{

fulfill::{FulfillmentCtxt, NextSolverError},

infer::{

snapshot::CombinedSnapshot,

traits::{Obligation, ObligationCause, PredicateObligation},

},

inspect::{InspectConfig, InspectGoal, ProofTreeVisitor},

obligation_ctxt::ObligationCtxt,

},

};

struct NestedObligationsForSelfTy<'a, 'db> {

impl<'a, 'db> ProofTreeVisitor<'db> for NestedObligationsForSelfTy<'a, 'db> {

type Result = ();

fn config(&self) -> InspectConfig {

// Using an intentionally low depth to minimize the chance of future

// breaking changes in case we adapt the approach later on. This also

if self.ctx.predicate_has_self_ty(goal.predicate, self.self_ty) {

self.obligations_for_self_ty.push(Obligation::new(

db,

goal.param_env,

goal.predicate,

));

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

let cause = ObligationCause::dummy();

let at = infcx.at(&cause, env.param_env);

let mut ctxt = ObligationCtxt::new(&infcx);

let can_unify = at

.eq(ty1_with_vars, ty2_with_vars)

can_unify && select(&mut ctxt).is_empty()

}

pub(crate) struct InferenceTable<'db> {

pub(crate) db: &'db dyn HirDatabase,

pub(crate) param_env: ParamEnv<'db>,

pub(crate) infer_ctxt: InferCtxt<'db>,

pub(super) fulfillment_cx: FulfillmentCtxt<'db>,

pub(super) diverging_type_vars: FxHashSet<Ty<'db>>,

}

impl<'db> InferenceTable<'db> {

db: &'db dyn HirDatabase,

trait_env: ParamEnv<'db>,

krate: Crate,

) -> Self {

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

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

InferenceTable {

db,

fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),

infer_ctxt,

diverging_type_vars: FxHashSet::default(),

}

}

self.infer_ctxt.type_is_copy_modulo_regions(self.param_env, ty)

}

pub(crate) fn type_is_use_cloned_modulo_regions(&self, ty: Ty<'db>) -> bool {

self.infer_ctxt.type_is_use_cloned_modulo_regions(self.param_env, ty)

}

self.diverging_type_vars.insert(ty);

}

}

}

pub(crate) fn next_int_var(&self) -> Ty<'db> {

self.infer_ctxt.next_float_var()

}

self.set_diverging(var);

var

}

}

}

pub(crate) fn at<'a>(&'a self, cause: &'a ObligationCause) -> At<'a, 'db> {

self.infer_ctxt.shallow_resolve(ty)

}

pub(crate) fn resolve_vars_with_obligations<T>(&mut self, t: T) -> T

where

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

}

/// Create a `GenericArgs` full of infer vars for `def`.

}

/// Try to resolve `ty` to a structural type, normalizing aliases.

/// In case there is still ambiguity, the returned type may be an inference

/// variable. This is different from `structurally_resolve_type` which errors

/// in this case.

if let TyKind::Alias(..) = ty.kind() {

let result = self

.infer_ctxt

.structurally_normalize_ty(ty, &mut self.fulfillment_cx);

match result {

Ok(normalized_ty) => normalized_ty,

}

} else {

self.resolve_vars_with_obligations(ty)

}

}

}

}

#[tracing::instrument(skip_all)]

}

pub(crate) fn commit_if_ok<T, E>(

let snapshot = self.snapshot();

let result = f(self);

match result {

}

result

}

pub(crate) fn register_bound(&mut self, ty: Ty<'db>, def_id: TraitId, cause: ObligationCause) {

if !ty.references_non_lt_error() {

let trait_ref = TraitRef::new(self.interner(), def_id.into(), [ty]);

}

pub(crate) fn select_obligations_where_possible(&mut self) {

}

pub(super) fn register_predicate(&mut self, obligation: PredicateObligation<'db>) {

where

I: IntoIterator<Item = PredicateObligation<'db>>,

{

}

/// checking later, during regionck, that `arg` is well-formed.

}

/// Registers obligations that all `args` are well-formed.

for term in args.iter().filter_map(|it| it.as_term()) {

}

}

self.infer_ctxt.insert_type_vars(ty)

}

/// Whenever you lower a user-written type, you should call this.

pub(crate) fn process_user_written_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {

self.process_remote_user_written_ty(ty)

}

/// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,

// See https://github.com/rust-lang/rust/blob/cdb45c87e2cd43495379f7e867e3cc15dcee9f93/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs#L487-L495:

// Even though the new solver only lazily normalizes usually, here we eagerly normalize so that not everything needs

// to normalize before inspecting the `TyKind`.

}

}

}

}

use crate::{

infer::unify::InferenceTable,

next_solver::{

infer::{resolve::ReplaceInferWithError, traits::ObligationCause},

normalize::deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,

},

};

pub(super) struct Resolver<'a, 'db> {

/// Whether we should normalize, disabled when resolving predicates.

should_normalize: bool,

nested_goals: &'a mut Vec<Goal<'db, Predicate<'db>>>,

impl<'a, 'db> Resolver<'a, 'db> {

pub(super) fn new(

should_normalize: bool,

nested_goals: &'a mut Vec<Goal<'db, Predicate<'db>>>,

) -> Resolver<'a, 'db> {

T: Into<Term<'db>> + TypeSuperFoldable<DbInterner<'db>> + Copy,

{

let value = if self.should_normalize {

let universes = vec![None; outer_exclusive_binder(value).as_usize()];

match deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(

at, value, universes,

self.nested_goals.extend(goals);

value

}

value

}

}

value

};

}

}

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

}

fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {

}

fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {