use std::fmt;

use hir_expand::name::Name;

use intern::sym;

use rustc_hash::FxHashSet;

use rustc_type_ir::{

};

use smallvec::SmallVec;

use crate::{

db::HirDatabase,

next_solver::{

fulfill::{FulfillmentCtxt, NextSolverError},

infer::{

DbInternerInferExt, InferCtxt, InferOk, InferResult,

snapshot::CombinedSnapshot,

traits::{Obligation, ObligationCause, PredicateObligation},

},

obligation_ctxt::ObligationCtxt,

},

traits::{

},

};

struct NestedObligationsForSelfTy<'a, 'db> {

ctx: &'a InferenceTable<'db>,

self_ty: TyVid,

let db = self.ctx.interner();

let goal = inspect_goal.goal();

self.obligations_for_self_ty.push(Obligation::new(

db,

self.root_cause.clone(),

/// unresolved goal `T = U`.

pub fn could_unify<'db>(

db: &'db dyn HirDatabase,

tys: &Canonical<'db, (Ty<'db>, Ty<'db>)>,

) -> bool {

could_unify_impl(db, env, tys, |ctxt| ctxt.try_evaluate_obligations())

/// them. For example `Option<T>` and `Option<U>` do not unify as we cannot show that `T = U`

pub fn could_unify_deeply<'db>(

db: &'db dyn HirDatabase,

tys: &Canonical<'db, (Ty<'db>, Ty<'db>)>,

) -> bool {

could_unify_impl(db, env, tys, |ctxt| ctxt.evaluate_obligations_error_on_ambiguity())

fn could_unify_impl<'db>(

db: &'db dyn HirDatabase,

tys: &Canonical<'db, (Ty<'db>, Ty<'db>)>,

select: for<'a> fn(&mut ObligationCtxt<'a, 'db>) -> Vec<NextSolverError<'db>>,

) -> bool {

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

let cause = ObligationCause::dummy();

let ((ty1_with_vars, ty2_with_vars), _) = infcx.instantiate_canonical(tys);

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

let can_unify = at

#[derive(Clone)]

pub(crate) struct InferenceTable<'db> {

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

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

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

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

/// Outside it, always pass `owner = None`.

pub(crate) fn new(

db: &'db dyn HirDatabase,

owner: Option<DefWithBodyId>,

) -> Self {

let typing_mode = match owner {

Some(owner) => TypingMode::typeck_for_body(interner, owner.into()),

// IDE things wants to reveal opaque types.

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

InferenceTable {

db,

fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),

infer_ctxt,

diverging_type_vars: FxHashSet::default(),

}

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

}

pub(crate) fn type_var_is_sized(&self, self_ty: TyVid) -> bool {

return true;

};

self.obligations_for_self_ty(self_ty).into_iter().any(|obligation| {

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

{

let ty = self.resolve_vars_with_obligations(ty);

}

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

self.infer_ctxt

.structurally_normalize_ty(alias, &mut self.fulfillment_cx)

.unwrap_or(alias)

}

self.infer_ctxt.next_ty_var()

}

self.infer_ctxt.next_const_var()

}

self.infer_ctxt.next_int_var()

}

self.infer_ctxt.next_float_var()

}

var

}

self.infer_ctxt.next_region_var()

}

}

pub(crate) fn resolve_completely<T>(&mut self, value: T) -> T

/// Unify two relatable values (e.g. `Ty`) and return new trait goals arising from it, so the

/// caller needs to deal with them.

pub(crate) fn try_unify<T: ToTrace<'db>>(&mut self, t1: T, t2: T) -> InferResult<'db, ()> {

}

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

self.infer_ctxt.fresh_args_for_item(def)

}

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

///

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

// in a reentrant borrow, causing an ICE.

let result = self

.infer_ctxt

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

match result {

Ok(normalized_ty) => normalized_ty,

self.fulfillment_cx = snapshot.obligations;

}

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

&mut self,

f: impl FnOnce(&mut InferenceTable<'db>) -> Result<T, E>,

/// choice (during e.g. method resolution or deref).

#[tracing::instrument(level = "debug", skip(self))]

pub(crate) fn try_obligation(&mut self, predicate: Predicate<'db>) -> NextTraitSolveResult {

let canonicalized = self.canonicalize(goal);

next_trait_solve_canonical_in_ctxt(&self.infer_ctxt, canonicalized)

}

pub(crate) fn register_obligation(&mut self, predicate: Predicate<'db>) {

self.register_obligation_in_env(goal)

}

#[tracing::instrument(level = "debug", skip(self))]

let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);

tracing::debug!(?result);

match result {

self.fulfillment_cx.register_predicate_obligation(&self.infer_ctxt, obligation);

}

where

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

{

});

}

pub(crate) fn callable_sig(

&mut self,

ty: Ty<'db>,

ty: Ty<'db>,

num_args: usize,

) -> Option<(FnTrait, Vec<Ty<'db>>, Ty<'db>)> {

for (fn_trait_name, output_assoc_name, subtraits) in [

(FnTrait::FnOnce, sym::Output, &[FnTrait::Fn, FnTrait::FnMut][..]),

(FnTrait::AsyncFnMut, sym::CallRefFuture, &[FnTrait::AsyncFn]),

(FnTrait::AsyncFnOnce, sym::CallOnceFuture, &[]),

] {

let trait_data = fn_trait.trait_items(self.db);

let output_assoc_type =

trait_data.associated_type_by_name(&Name::new_symbol_root(output_assoc_name))?;

})

.take(num_args),

);

let projection = Ty::new_alias(

self.interner(),

rustc_type_ir::AliasTyKind::Projection,

);

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

self.register_obligation(pred);

let return_ty = self.normalize_alias_ty(projection);

for &fn_x in subtraits {

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

if !self.try_obligation(pred).no_solution() {

return Some((fn_x, arg_tys, return_ty));

}

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

self.process_remote_user_written_ty(ty)

// FIXME: Register a well-formed obligation.

}

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

/// while `process_user_written_ty()` should (but doesn't currently).

let ty = self.insert_type_vars(ty);

// 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`.

// FIXME(next-solver): We should not deeply normalize here, only shallowly.

}

/// Replaces ConstScalar::Unknown by a new type var, so we can maybe still infer it.

}

let mut ty = ty;

if let Some(sized) = short_circuit_trivial_tys(ty) {

return sized;

}

let struct_data = id.fields(self.db);

if let Some((last_field, _)) = struct_data.fields().iter().next_back() {

let last_field_ty = self.db.field_types(id.into())[last_field]

.instantiate(self.interner(), subst);

if structs.contains(&ty) {

// A struct recursively contains itself as a tail field somewhere.

// Structs can have DST as its last field and such cases are not handled

// as unsized by the chalk, so we do this manually.

ty = last_field_ty;

if let Some(sized) = short_circuit_trivial_tys(ty) {

return sized;

}

}

}

return false;

};

let sized_pred = Predicate::upcast_from(

{

let value = if self.should_normalize {

let cause = ObligationCause::new();

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

match deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(

at, value, universes,