use std::fmt;

use hir_expand::name::Name;

use intern::sym;

use rustc_hash::{FxHashMap, FxHashSet};

use rustc_type_ir::{

solve::{Certainty, GoalSource},

};

use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

next_solver::{

infer::{

snapshot::CombinedSnapshot,

},

inspect::{InspectConfig, InspectGoal, ProofTreeVisitor},

},

traits::{

FnTrait, NextTraitSolveResult, next_trait_solve_canonical_in_ctxt, next_trait_solve_in_ctxt,

},

};

pub(super) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>

where

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

return;

}

let goal = inspect_goal.goal();

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

// We do not push the instantiated forms of goals as it would cause any

/// This means that there may be some unresolved goals that actually set bounds for the placeholder

/// type for the types to unify. For example `Option<T>` and `Option<U>` unify although there is

/// unresolved goal `T = U`.

) -> bool {

}

/// Check if types unify eagerly making sure there are no unresolved goals.

///

/// This means that placeholder types are not considered to unify if there are any bounds set on

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

) -> bool {

}

}

#[derive(Clone)]

pub(crate) struct InferenceTable<'db> {

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

pub(crate) trait_env: Arc<TraitEnvironment<'db>>,

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

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

}

pub(crate) struct InferenceTableSnapshot<'db> {

});

InferenceTable {

db,

trait_env,

tait_coercion_table: None,

fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),

}

}

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

let Some(sized_did) = LangItem::Sized.resolve_trait(self.db, self.trait_env.krate) else {

return true;

};

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

match obligation.predicate.kind().skip_binder() {

_ => false,

}

})

}

}

let ty = self.shallow_resolve(ty);

match ty.kind() {

self.infer_ctxt.root_var(expected_vid) == self.infer_ctxt.root_var(found_vid)

}

_ => false,

}

}

self.diverging_type_vars.insert(ty);

}

pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>

where

{

// try to resolve obligations before canonicalizing, since this might

// result in new knowledge about variables

self.infer_ctxt.canonicalize_response(t)

}

// FIXME: We should get rid of this method. We cannot deeply normalize during inference, only when finishing.

// Inference should use shallow normalization (`try_structurally_resolve_type()`) only, when needed.

where

{

let ty = self.resolve_vars_with_obligations(ty);

self.infer_ctxt

/// the inference variables

pub(crate) fn eagerly_normalize_and_resolve_shallow_in<T>(&mut self, ty: T) -> T

where

{

}

}

self.infer_ctxt.next_ty_var()

}

}

}

}

}

}

}

pub(crate) fn resolve_with_fallback<T>(

&mut self,

t: T,

) -> T

where

{

}

}

&mut self,

canonical: rustc_type_ir::Canonical<DbInterner<'db>, T>,

) -> T

self.infer_ctxt.instantiate_canonical(&canonical).0

}

where

{

let value = self.infer_ctxt.resolve_vars_if_possible(value);

let mut goals = vec![];

// FIXME(next-solver): Handle `goals`.

}

/// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.

}

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

/// caller needs to deal with them.

}

self.infer_ctxt.shallow_resolve(ty)

}

where

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

{

if !t.has_non_region_infer() {

return t;

}

self.infer_ctxt.resolve_vars_if_possible(t)

}

}

}

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

// We need to use a separate variable here as otherwise the temporary for

// `self.fulfillment_cx.borrow_mut()` is alive in the `Err` branch, resulting

// in a reentrant borrow, causing an ICE.

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

match result {

Ok(normalized_ty) => normalized_ty,

}

} else {

self.resolve_vars_with_obligations(ty)

}

}

pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot<'db> {

let ctxt_snapshot = self.infer_ctxt.start_snapshot();

let obligations = self.fulfillment_cx.clone();

self.fulfillment_cx.register_predicate_obligation(

&self.infer_ctxt,

Obligation::new(

ObligationCause::new(),

goal.param_env,

goal.predicate,

value

}

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

self.fulfillment_cx.try_evaluate_obligations(&self.infer_ctxt);

}

if obligation.has_escaping_bound_vars() {

panic!("escaping bound vars in predicate {:?}", obligation);

}

pub(super) fn register_predicates<I>(&mut self, obligations: I)

where

{

obligations.into_iter().for_each(|obligation| {

self.register_predicate(obligation);

pub(crate) fn callable_sig(

&mut self,

num_args: usize,

None => {

let (f, args_ty, return_ty) = self.callable_sig_from_fn_trait(ty, num_args)?;

Some((Some(f), args_ty, return_ty))

fn callable_sig_from_fn_trait(

&mut self,

num_args: usize,

for (fn_trait_name, output_assoc_name, subtraits) in [

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

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

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

let mut arg_tys = Vec::with_capacity(num_args);

std::iter::repeat_with(|| {

let ty = self.next_ty_var();

arg_tys.push(ty);

})

.take(num_args),

);

rustc_type_ir::AliasTyKind::Projection,

);

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

self.register_obligation(pred);

let return_ty = self.normalize_alias_ty(projection);

for &fn_x in subtraits {

let fn_x_trait = fn_x.get_id(self.db, krate)?;

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

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

}

pub(super) fn insert_type_vars<T>(&mut self, ty: T) -> T

where

{

}

}

}

}

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

where

{

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

where

{

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:

}

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

}

/// Check if given type is `Sized` or not

| TyKind::Ref(..)

| TyKind::Never

| TyKind::FnDef(..)

| TyKind::Array(..)

_ => None,

}

}

ty = self.eagerly_normalize_and_resolve_shallow_in(ty);

return sized;

}

while let Some((AdtId::StructId(id), subst)) = ty.as_adt() {

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

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

if structs.contains(&ty) {

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

return true; // Don't overload the users with too many errors.

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

ty = last_field_ty;

ty = self.eagerly_normalize_and_resolve_shallow_in(ty);

return sized;

}

} else {

return false;

};

let sized_pred = Predicate::upcast_from(

);

self.try_obligation(sized_pred).certain()

}

}

}

mod resolve_completely {

use crate::{

infer::unify::InferenceTable,

next_solver::{

normalize::deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,

},

};

value

};

}

}

impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Resolver<'cx, 'db> {

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> {

predicate.super_fold_with(self)

}

}

}