use std::iter;

use tracing::debug;

use rustc_type_ir::{

InferTy, Interner,

inherent::{GenericArgs as _, IntoKind, Ty as _},

};

use crate::{

autoderef::{GeneralAutoderef, InferenceContextAutoderef},

infer::{

AllowTwoPhase, AutoBorrowMutability, Expectation, InferenceContext, InferenceDiagnostic,

},

method_resolution::{MethodCallee, TreatNotYetDefinedOpaques},

next_solver::{

infer::{BoundRegionConversionTime, traits::ObligationCause},

},

};

) -> Ty<'db> {

let original_callee_ty = self.infer_expr_no_expect(callee_expr, ExprIsRead::Yes);

let mut result = None;

while result.is_none() && autoderef.next().is_some() {

}

// FIXME: rustc does some ABI checks here, but the ABI mapping is in rustc_target and we don't have access to that crate.

self.infer_expr_no_expect(arg, ExprIsRead::Yes);

}

self.types.types.error

}

Some(CallStep::Builtin(callee_ty)) => {

}

Some(CallStep::DeferredClosure(_def_id, fn_sig)) => {

};

// we must check that return type of called functions is WF:

output

}

callee_expr: ExprId,

arg_exprs: &[ExprId],

autoderef: &mut InferenceContextAutoderef<'_, '_, 'db>,

) -> Option<CallStep<'db>> {

let final_ty = autoderef.final_ty();

// If the callee is a function pointer or a closure, then we're all set.

match adjusted_ty.kind() {

{

let closure_sig = args.as_closure().sig();

let closure_sig = autoderef.ctx().infcx().instantiate_binder_with_fresh_vars(

BoundRegionConversionTime::FnCall,

closure_sig,

);

let adjust_steps = autoderef.adjust_steps_as_infer_ok();

let adjustments = autoderef.ctx().table.register_infer_ok(adjust_steps);

autoderef.ctx().record_deferred_call_resolution(

def_id,

DeferredCallResolution {

let closure_args = args.as_coroutine_closure();

let coroutine_closure_sig =

autoderef.ctx().infcx().instantiate_binder_with_fresh_vars(

BoundRegionConversionTime::FnCall,

closure_args.coroutine_closure_sig(),

);

// We may actually receive a coroutine back whose kind is different

// from the closure that this dispatched from. This is because when

// we have no captures, we automatically implement `FnOnce`. This

// impl forces the closure kind to `FnOnce` i.e. `u8`.

let interner = autoderef.ctx().interner();

let call_sig = interner.mk_fn_sig(

[coroutine_closure_sig.tupled_inputs_ty],

interner.coroutine_for_closure(def_id),

tupled_upvars_ty,

),

);

let adjust_steps = autoderef.adjust_steps_as_infer_ok();

let adjustments = autoderef.ctx().table.register_infer_ok(adjust_steps);

autoderef.ctx().record_deferred_call_resolution(

def_id,

DeferredCallResolution {

autoderef

.ctx()

.type_must_be_known_at_this_point(callee_expr.into(), adjusted_ty);

return None;

}

// is implemented, and use this information for diagnostic.

autoderef

.ctx()

.map(|(autoref, method)| {

let adjustments = autoderef.adjust_steps_as_infer_ok();

let mut adjustments = autoderef.ctx().table.register_infer_ok(adjustments);

fn try_overloaded_call_traits(

&mut self,

adjusted_ty: Ty<'db>,

opt_arg_exprs: Option<&[ExprId]>,

) -> Option<(Option<Adjustment>, MethodCallee<'db>)> {

// ...or *ideally*, we just have `LendingFn`/`LendingFnMut`, which

// would naturally unify these two trait hierarchies in the most

// general way.

let call_trait_choices = if self.shallow_resolve(adjusted_ty).is_coroutine_closure() {

[

]

} else {

[

]

};

// Try the options that are least restrictive on the caller first.

continue;

};

let opt_input_type = opt_arg_exprs.map(|arg_exprs| {

Ty::new_tup_from_iter(

self.interner(),

)

});

// one which may apply. So if we treat opaques as inference variables

// `Box<impl FnOnce()>: Fn` is considered ambiguous and chosen.

if let Some(ok) = self.table.lookup_method_for_operator(

trait_def_id,

adjusted_ty,

opt_input_type,

TreatNotYetDefinedOpaques::AsRigid,

fn check_legacy_const_generics(

&mut self,

callee: Option<CallableDefId>,

args: &[ExprId],

) -> Box<[u32]> {

_ => return Default::default(),

};

let data = FunctionSignature::of(self.db, func);

let Some(legacy_const_generics_indices) = data.legacy_const_generics_indices(self.db, func)

}

// check legacy const parameters

if arg_idx >= args.len() as u32 {

continue;

}

self.infer_expr(args[arg_idx as usize], &expected, ExprIsRead::Yes);

// FIXME: evaluate and unify with the const

}

fn confirm_builtin_call(

&mut self,

call_expr: ExprId,

callee_ty: Ty<'db>,

arg_exprs: &[ExprId],

) -> Ty<'db> {

let (fn_sig, def_id) = match callee_ty.kind() {

TyKind::FnDef(def_id, args) => {

(fn_sig, Some(def_id.0))

}

// renormalize the associated types at this point, since they

// previously appeared within a `Binder<>` and hence would not

// have been normalized before.

self.check_call_arguments(

call_expr,

fn_sig.inputs(),

expected,

arg_exprs,

&indices_to_skip,

TupleArgumentsFlag::DontTupleArguments,

);

&& let Some(ty) = fn_sig.inputs().last().copied()

&& let Some(tuple_trait) = self.lang_items.Tuple

{

}

fn_sig.output()

expected,

arg_exprs,

&[],

TupleArgumentsFlag::TupleArguments,

);

expected,

arg_exprs,

&[],

TupleArgumentsFlag::TupleArguments,

);

assert!(ctx.infcx().closure_kind(self.closure_ty).is_some());

// We may now know enough to figure out fn vs fnmut etc.

Some((autoref, method_callee)) => {

// One problem is that when we get here, we are going

// to have a newly instantiated function signature