use either::Either;

use hir_def::{

expr_store::path::{GenericArgs as HirGenericArgs, Path},

hir::{

Array, AsmOperand, AsmOptions, BinaryOp, BindingAnnotation, Expr, ExprId, ExprOrPatId,

},

resolver::ValueNs,

signatures::VariantFields,

use hir_def::{FunctionId, hir::ClosureKind};

use hir_expand::name::Name;

use rustc_ast_ir::Mutability;

use rustc_type_ir::{

InferTy, Interner,

};

use syntax::ast::RangeOp;

use tracing::debug;

use crate::{

method_resolution::{self, CandidateId, MethodCallee, MethodError},

next_solver::{

infer::{

BoundRegionConversionTime, InferOk,

traits::{Obligation, ObligationCause},

},

obligation_ctxt::ObligationCtxt,

},

};

use super::{

cast::CastCheck, find_breakable,

};

) -> Ty<'db> {

let ty = self.infer_expr_inner(tgt_expr, expected, is_read);

if let Some(expected_ty) = expected.only_has_type(&mut self.table) {

}

ty

}

pub(crate) fn infer_expr_no_expect(

&mut self,

tgt_expr: ExprId,

) -> Ty<'db> {

let ty = self.infer_expr_inner(expr, expected, is_read);

if let Some(target) = expected.only_has_type(&mut self.table) {

Ok(res) => res,

Err(_) => {

target

}

}

fn pat_guaranteed_to_constitute_read_for_never(&self, pat: PatId) -> bool {

match &self.store[pat] {

// Does not constitute a read.

// This is unnecessarily restrictive when the pattern that doesn't

// constitute a read is unreachable.

| Pat::Path(_)

| Pat::Tuple { .. }

| Pat::Box { .. }

| Pat::Ref { .. }

| Pat::Lit(_)

| Pat::Range { .. }

}

}

pub(crate) fn check_lhs_assignable(&self, lhs: ExprId) {

if self.is_syntactic_place_expr(lhs) {

return;

}

}

fn infer_expr_coerce_never(

}

if let Some(target) = expected.only_has_type(&mut self.table) {

.expect("never-to-any coercion should always succeed")

} else {

ty

}

} else {

if let Some(expected_ty) = expected.only_has_type(&mut self.table) {

}

ty

}

}

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

&mut self,

tgt_expr: ExprId,

expected: &Expectation<'db>,

let ty = match expr {

Expr::Missing => self.err_ty(),

&Expr::If { condition, then_branch, else_branch } => {

self.infer_expr_coerce_never(

condition,

&Expectation::HasType(self.types.types.bool),

coercion_sites[1] = else_branch;

}

let mut coerce = CoerceMany::with_coercion_sites(

&coercion_sites,

);

match else_branch {

Some(else_branch) => {

let else_ty = self.infer_expr_inner(else_branch, expected, ExprIsRead::Yes);

let else_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);

coerce.coerce(

self,

else_branch,

else_ty,

ExprIsRead::Yes,

coerce.coerce_forced_unit(

self,

tgt_expr,

true,

ExprIsRead::Yes,

);

ExprIsRead::No

};

let input_ty = self.infer_expr(expr, &Expectation::none(), child_is_read);

self.types.types.bool

}

Expr::Block { statements, tail, label, id: _ } => {

.1

}

&Expr::Loop { body, label } => {

let (breaks, ()) =

self.with_breakable_ctx(BreakableKind::Loop, Some(ty), label, |this| {

this.infer_expr(

let matchee_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);

let mut all_arms_diverge = Diverges::Always;

for arm in arms.iter() {

}

let result_ty = match &expected {

// We don't coerce to `()` so that if the match expression is a

// statement it's branches can have any consistent type.

Expectation::HasType(ty) if *ty != self.types.types.unit => *ty,

};

let mut coerce = CoerceMany::new(result_ty);

all_arms_diverge &= self.diverges;

coerce.coerce(

self,

arm.expr,

arm_ty,

ExprIsRead::Yes,

match find_breakable(&mut self.breakables, label) {

Some(ctxt) => match ctxt.coerce.take() {

Some(mut coerce) => {

coerce.coerce(

self,

val_ty,

ExprIsRead::Yes,

);

} else {

let unit = self.types.types.unit;

let _ = self.coerce(

unit,

yield_ty,

AllowTwoPhase::No,

self.types.types.never

}

Expr::RecordLit { path, fields, spread, .. } => {

}

Expr::Field { expr, name } => self.infer_field_access(tgt_expr, *expr, name, expected),

Expr::Cast { expr, type_ref } => {

let cast_ty = self.make_body_ty(*type_ref);

let expr_ty =

self.deferred_cast_checks.push(CastCheck::new(tgt_expr, *expr, expr_ty, cast_ty));

cast_ty

}

&Expr::Box { expr } => self.infer_expr_box(expr, expected),

Expr::UnaryOp { expr, op } => self.infer_unop_expr(*op, *expr, expected, tgt_expr),

Expr::BinaryOp { lhs, rhs, op } => match op {

&Pat::Expr(expr) => {

Some(self.infer_expr(expr, &Expectation::none(), ExprIsRead::No))

}

_ => None,

};

let is_destructuring_assignment = lhs_ty.is_none();

} else {

let rhs_ty = self.infer_expr(value, &Expectation::none(), ExprIsRead::Yes);

let resolver_guard =

self.inside_assignment = true;

self.inside_assignment = false;

self.resolver.reset_to_guard(resolver_guard);

}

// However, rustc lowers destructuring assignments into blocks, and blocks return `!` if they have no tail

// expression and they diverge. Therefore, we have to do the same here, even though we don't lower destructuring

// assignments into blocks.

} else {

self.types.types.unit

}

let base_t = self.infer_expr_no_expect(*base, ExprIsRead::Yes);

let idx_t = self.infer_expr_no_expect(*index, ExprIsRead::Yes);

Some((trait_index_ty, trait_element_ty)) => {

// two-phase not needed because index_ty is never mutable

self.demand_coerce(

Expr::Tuple { exprs, .. } => {

let mut tys = match expected

.only_has_type(&mut self.table)

{

Some(TyKind::Tuple(substs)) => substs

.iter()

.take(exprs.len())

.collect::<Vec<_>>(),

};

for (expr, ty) in exprs.iter().zip(tys.iter_mut()) {

Ty::new_tup(self.interner(), &tys)

}

},

},

},

Expr::Underscore => {

// Underscore expression is an error, we render a specialized diagnostic

// to let the user know what type is expected though.

self.push_diagnostic(InferenceDiagnostic::TypedHole {

expr: tgt_expr,

expected: expected.store(),

// allows them to be inferred based on how they are used later in the

// function.

if is_input {

match ty.kind() {

TyKind::FnDef(def, parameters) => {

let fnptr_ty = Ty::new_fn_ptr(

this.interner(),

this.interner()

.fn_sig(def)

);

_ = this.coerce(

ty,

fnptr_ty,

AllowTwoPhase::No,

TyKind::Ref(_, base_ty, mutbl) => {

let ptr_ty = Ty::new_ptr(this.interner(), base_ty, mutbl);

_ = this.coerce(

ty,

ptr_ty,

AllowTwoPhase::No,

}

}

};

let ty = self.insert_type_vars_shallow(ty);

self.write_expr_ty(tgt_expr, ty);

if self.shallow_resolve(ty).is_never()

ty

}

fn demand_scrutinee_type(

&mut self,

scrut: ExprId,

// ...but otherwise we want to use any supertype of the

// scrutinee. This is sort of a workaround, see note (*) in

// `check_pat` for some details.

self.infer_expr_coerce_never(scrut, &Expectation::HasType(scrut_ty), scrutinee_is_read);

scrut_ty

}

}

fn infer_expr_path(&mut self, path: &Path, id: ExprOrPatId, scope_id: ExprId) -> Ty<'db> {

let ty = match self.infer_path(path, id) {

None => {

if path.mod_path().is_some_and(|mod_path| mod_path.is_ident() || mod_path.is_self())

{

};

let mut oprnd_t = self.infer_expr_inner(oprnd, expected_inner, ExprIsRead::Yes);

match unop {

UnaryOp::Deref => {

if let Some(ty) = self.lookup_derefing(expr, oprnd, oprnd_t) {

}

oprnd_t

}

}

}

}

};

}

pub(super) fn infer_return(&mut self, expr: ExprId) {

let return_expr_ty =

self.infer_expr_inner(expr, &Expectation::HasType(ret_ty), ExprIsRead::Yes);

let mut coerce_many = self.return_coercion.take().unwrap();

self.return_coercion = Some(coerce_many);

}

coerce.coerce_forced_unit(

self,

ret,

true,

ExprIsRead::Yes,

);

// NB: this should *not* coerce.

// tail calls don't support any coercions except lifetimes ones (like `&'static u8 -> &'a u8`).

}

None => {

// FIXME: diagnose `become` outside of functions

.unwrap_or_else(Expectation::none);

let inner_ty = self.infer_expr_inner(inner_expr, &inner_exp, ExprIsRead::Yes);

} else {

self.err_ty()

}

label: Option<LabelId>,

expected: &Expectation<'db>,

) -> Ty<'db> {

let (break_ty, ty) =

self.with_breakable_ctx(BreakableKind::Block, Some(coerce_ty), label, |this| {

let decl_ty = type_ref

.as_ref()

.map(|&tr| this.make_body_ty(tr))

let ty = if let Some(expr) = initializer {

// If we have a subpattern that performs a read, we want to consider this

} else {

ExprIsRead::No

};

this.infer_expr(

*expr,

&Expectation::has_type(decl_ty),

decl_ty

};

if let Some(expr) = else_branch {

let previous_diverges =

mem::replace(&mut this.diverges, Diverges::Maybe);

// `!`).

if this.diverges.is_always() {

// we don't even make an attempt at coercion

} else if let Some(t) = expected.only_has_type(&mut this.table) {

if this

.coerce(

this.types.types.unit,

t,

AllowTwoPhase::No,

)

.is_err()

{

}

t

} else {

fn lookup_field(

&mut self,

receiver_ty: Ty<'db>,

name: &Name,

) -> Option<(Ty<'db>, Either<FieldId, TupleFieldId>, Vec<Adjustment>, bool)> {

let interner = self.interner();

let mut private_field = None;

let res = autoderef.by_ref().find_map(|(derefed_ty, _)| {

let (field_id, parameters) = match derefed_ty.kind() {

})

});

}

hir_def::AdtId::StructId(s) => {

let local_id = s.fields(self.db).field(name)?;

let field = FieldId { parent: s.into(), local_id };

}

let ty = self.db.field_types(field_id.parent)[field_id.local_id]

.get()

Some((Either::Left(field_id), ty))

});

self.table.register_infer_ok(autoderef.adjust_steps_as_infer_ok());

let ty = self.db.field_types(field_id.parent)[field_id.local_id]

.get()

let ty = self.process_remote_user_written_ty(ty);

(ty, Either::Left(field_id), adjustments, false)

) -> Ty<'db> {

// Field projections don't constitute reads.

let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::No);

if name.is_missing() {

// Bail out early, don't even try to look up field. Also, we don't issue an unresolved

return self.err_ty();

}

Some((ty, field_id, adjustments, is_public)) => {

self.write_expr_adj(receiver, adjustments.into_boxed_slice());

self.result.field_resolutions.insert(tgt_expr, field_id);

fn instantiate_erroneous_method(&mut self, def_id: FunctionId) -> MethodCallee<'db> {

// FIXME: Using fresh infer vars for the method args isn't optimal,

// we can do better by going thorough the full probe/confirm machinery.

MethodCallee { def_id, args, sig }

}

&mut self,

tgt_expr: ExprId,

args: &[ExprId],

is_varargs: bool,

expected: &Expectation<'db>,

) -> Ty<'db> {

self.check_call_arguments(

tgt_expr,

expected: &Expectation<'db>,

) -> Ty<'db> {

let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);

let resolved = self.lookup_method_including_private(

receiver_ty,

// Failed to resolve, report diagnostic and try to resolve as call to field access or

// assoc function

Err(_) => {

let assoc_func_with_same_name = match assoc_func_with_same_name {

Ok(method_resolution::Pick {

item: CandidateId::FunctionId(def_id), ..

}),

};

match recovered {

tgt_expr,

args,

callee_ty,

expected,

args,

&[],

TupleArgumentsFlag::DontTupleArguments,

);

ret_ty

let formal_input_tys: Vec<_> = formal_input_tys

.iter()

.map(|&ty| {

let _ = self.demand_eqtype(call_expr.into(), ty, generalized_ty);

generalized_ty

})

// return type (likely containing type variables if the function

// is polymorphic) and the expected return type.

// No argument expectations are produced if unification fails.

ocx.sup(&origin, self.table.param_env, expected_output, formal_output)?;

for &ty in &formal_input_tys {

ocx.register_obligation(Obligation::new(

self.interner(),

self.table.param_env,

ClauseKind::WellFormed(ty.into()),

));

.unwrap_or_default();

// If the arguments should be wrapped in a tuple (ex: closures), unwrap them here

// FIXME: Emit an error.

}

}

// If there are no external expectations at the call site, just use the types from the function defn

let expected_input_tys = if let Some(expected_input_tys) = expected_input_tys {

let coerced_ty = this.table.resolve_vars_with_obligations(coerced_ty);

let coerce_error = this

.err();

if coerce_error.is_some() {

return Err((coerce_error, coerced_ty, checked_ty));

let formal_ty_error = this

.table

.infer_ctxt

.eq(formal_input_ty, coerced_ty);

// If neither check failed, the types are compatible

// closure wrapped in a block.

// See <https://github.com/rust-lang/rust/issues/112225>.

let is_closure = if let Expr::Closure { closure_kind, .. } = self.store[*arg] {

} else {

false

};

&& args_count_matches

{

// Don't report type mismatches if there is a mismatch in args count.

}

}

}

if !args_count_matches {}

}

pub(super) fn with_breakable_ctx<T>(

&mut self,

kind: BreakableKind,