use std::fmt;

use hir_expand::name::Name;

use intern::sym;

use rustc_type_ir::{

};

use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

db::HirDatabase,

next_solver::{

infer::{

snapshot::CombinedSnapshot,

},

inspect::{InspectConfig, InspectGoal, ProofTreeVisitor},

},

traits::{

FnTrait, NextTraitSolveResult, next_trait_solve_canonical_in_ctxt, next_trait_solve_in_ctxt,

},

};

struct NestedObligationsForSelfTy<'a, 'db> {

ctx: &'a InferenceTable<'db>,

self_ty: TyVid,

return;

}

let goal = inspect_goal.goal();

self.obligations_for_self_ty.push(Obligation::new(

db,

self.root_cause.clone(),

/// 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) infer_ctxt: InferCtxt<'db>,

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

}

pub(crate) struct InferenceTableSnapshot<'db> {

ctxt_snapshot: CombinedSnapshot,

obligations: FulfillmentCtxt<'db>,

}

impl<'db> InferenceTable<'db> {

InferenceTable {

db,

trait_env,

fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),

infer_ctxt,

}

}

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

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,

}

}

}

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

}

}

}

}

}

self.infer_ctxt.next_region_var()

}

}

where

{

}

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

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)

}

}

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

let ctxt_snapshot = self.infer_ctxt.start_snapshot();

let obligations = self.fulfillment_cx.clone();

}

#[tracing::instrument(skip_all)]

pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot<'db>) {

self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);

self.fulfillment_cx = snapshot.obligations;

}

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

&mut self,

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

/// whether a trait *might* be implemented before deciding to 'lock in' the

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

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

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::new(

ObligationCause::new(),

goal.param_env,

goal.predicate,

value

}

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

}

if obligation.has_escaping_bound_vars() {

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

}

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

}

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]),

(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))?;

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

})

for &fn_x in subtraits {

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

}

}

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

where

{

}

/// Replaces `Ty::Error` by a new type var, so we can maybe still infer it.

}

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

}

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

| TyKind::Ref(..)

| TyKind::Never

| TyKind::FnDef(..)

| TyKind::Array(..)

_ => None,

}

}

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]

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.

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

return sized;

}

} else {

}

}

return false;

};

}

}

}

}

use crate::{

};

}

}

&mut self,

}

}

}

}

}

}

}

}