use std::{iter::repeat_with, mem};

use either::Either;

use hir_def::hir::ClosureKind;

use hir_def::{

BlockId, FieldId, GenericDefId, GenericParamId, ItemContainerId, Lookup, TupleFieldId, TupleId,

hir::{

ArithOp, Array, AsmOperand, AsmOptions, BinaryOp, Expr, ExprId, ExprOrPatId, LabelId,

Literal, Pat, PatId, Statement, UnaryOp, generics::GenericParamDataRef,

};

use hir_expand::name::Name;

use intern::sym;

use syntax::ast::RangeOp;

use tracing::debug;

use crate::{

generics::generics,

infer::{

AllowTwoPhase, BreakableKind,

pat::contains_explicit_ref_binding,

},

lang_items::lang_items_for_bin_op,

path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},

},

method_resolution::{self, VisibleFromModule},

next_solver::{

},

traits::FnTrait,

};

No,

}

pub(crate) fn infer_expr(

&mut self,

tgt_expr: ExprId,

is_read: ExprIsRead,

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

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

if !could_unify {

}

}

ty

}

self.infer_expr_inner(tgt_expr, &Expectation::None, is_read)

}

pub(super) fn infer_expr_coerce(

&mut self,

expr: ExprId,

is_read: ExprIsRead,

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

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

let coerce_never = if self.expr_guaranteed_to_constitute_read_for_never(expr, is_read) {

} else {

CoerceNever::No

};

Err(_) => {

target

}

}

fn infer_expr_coerce_never(

&mut self,

expr: ExprId,

is_read: ExprIsRead,

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

// While we don't allow *arbitrary* coercions here, we *do* allow

// coercions from `!` to `expected`.

if ty.is_never() {

if let Some(adjustments) = self.result.expr_adjustments.get(&expr) {

return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &**adjustments {

} else {

self.err_ty()

};

}

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

} else {

ty

}

} else {

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

if !could_unify {

}

}

ty

fn infer_expr_inner(

&mut self,

tgt_expr: ExprId,

is_read: ExprIsRead,

self.db.unwind_if_revision_cancelled();

let expr = &self.body[tgt_expr];

let expected = &expected.adjust_for_branches(&mut self.table);

self.infer_expr_coerce_never(

condition,

ExprIsRead::Yes,

);

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

self.diverges = condition_diverges | then_diverges & else_diverges;

}

None => {

}

}

}

&Expr::Let { pat, expr } => {

let child_is_read = if self.pat_guaranteed_to_constitute_read_for_never(pat) {

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

self.infer_top_pat(

pat,

Some(DeclContext { origin: DeclOrigin::LetExpr }),

);

}

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

self.infer_block(tgt_expr, *id, statements, *tail, *label, expected)

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

// FIXME: should be:

// let ty = expected.coercion_target_type(&mut self.table);

let (breaks, ()) =

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

this.infer_expr(

body,

ExprIsRead::Yes,

);

});

self.diverges = Diverges::Maybe;

breaks

}

}

}

Expr::Closure { body, args, ret_type, arg_types, closure_kind, capture_by: _ } => self

if arms.is_empty() {

self.diverges = Diverges::Always;

} else {

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

let mut all_arms_diverge = Diverges::Always;

for arm in arms.iter() {

}

let expected = expected.adjust_for_branches(&mut self.table);

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.

};

for arm in arms.iter() {

if let Some(guard_expr) = arm.guard {

self.diverges = Diverges::Maybe;

self.infer_expr_coerce_never(

guard_expr,

ExprIsRead::Yes,

);

}

let arm_ty = self.infer_expr_inner(arm.expr, &expected, ExprIsRead::Yes);

all_arms_diverge &= self.diverges;

}

self.diverges = matchee_diverges | all_arms_diverge;

}

}

Expr::Path(p) => self.infer_expr_path(p, tgt_expr.into(), tgt_expr),

bad_value_break: false,

});

};

}

&Expr::Break { expr, label } => {

let val_ty = if let Some(expr) = expr {

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

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

None => {

self.push_diagnostic(InferenceDiagnostic::BreakOutsideOfLoop {

expr: tgt_expr,

ExprIsRead::Yes,

)

} else {

};

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

self,

&ObligationCause::new(),

expr.unwrap_or(tgt_expr),

);

// Avoiding borrowck

});

}

}

}

&Expr::Return { expr } => self.infer_expr_return(tgt_expr, expr),

&Expr::Become { expr } => self.infer_expr_become(expr),

Expr::Yield { expr } => {

if let Some(expr) = expr {

self.infer_expr_coerce(

*expr,

ExprIsRead::Yes,

);

} else {

let _ = self.coerce(

tgt_expr.into(),

AllowTwoPhase::No,

CoerceNever::Yes,

);

resume_ty

} else {

// FIXME: report error (yield expr in non-coroutine)

}

}

Expr::Yeet { expr } => {

if let &Some(expr) = expr {

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

}

}

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

let (ty, def_id) = self.resolve_variant(tgt_expr.into(), path.as_deref(), false);

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

}

if let Some(variant) = def_id {

self.write_variant_resolution(tgt_expr.into(), variant);

}

match def_id {

_ if fields.is_empty() => {}

Some(def) => {

let variant_data = def.fields(self.db);

let visibilities = self.db.field_visibilities(def);

for field in fields.iter() {

}

};

let field_ty = field_def.map_or(self.err_ty(), |it| {

});

// Field type might have some unknown types

}

}

if let Some(expr) = spread {

}

ty

}

}

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

let cast_ty = self.make_body_ty(*type_ref);

cast_ty

}

Expr::Ref { expr, rawness, mutability } => {

let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) = expected

.only_has_type(&mut self.table)

.as_ref()

// FIXME: record type error - expected reference but found ptr,

// which cannot be coerced

}

} else {

Expectation::none()

};

let inner_ty = self.infer_expr_inner(*expr, &expectation, ExprIsRead::Yes);

match rawness {

Rawness::Ref => {

}

}

}

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

Expr::UnaryOp { expr, op } => {

let inner_ty = self.infer_expr_inner(*expr, &Expectation::none(), ExprIsRead::Yes);

// FIXME: Note down method resolution her

match op {

UnaryOp::Deref => {

{

// FIXME: this is wrong in multiple ways, subst is empty, and we emit it even for builtin deref (note that

// the mutability is not wrong, and will be fixed in `self.infer_mut`).

}

} else {

match infer_ok {

None => self.err_ty(),

}

}

}

UnaryOp::Neg => {

// Fast path for builtins

// Otherwise we resolve via the std::ops::Neg trait

_ => self

.resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),

}

}

UnaryOp::Not => {

// Fast path for builtins

// Otherwise we resolve via the std::ops::Not trait

_ => self

.resolve_associated_type(inner_ty, self.resolve_ops_not_output()),

}

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

Some(BinaryOp::LogicOp(_)) => {

let lhs_diverges = self.diverges;

// Depending on the LHS' value, the RHS can never execute.

self.diverges = lhs_diverges;

bool_ty

let is_destructuring_assignment = lhs_ty.is_none();

if let Some(lhs_ty) = lhs_ty {

self.infer_expr_coerce(value, &Expectation::has_type(lhs_ty), ExprIsRead::No);

} else {

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

let resolver_guard =

self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);

self.inside_assignment = true;

self.inside_assignment = false;

self.resolver.reset_to_guard(resolver_guard);

}

// assignments into blocks.

self.table.new_maybe_never_var()

} else {

}

}

Expr::Range { lhs, rhs, range_type } => {

let lhs_ty =

lhs.map(|e| self.infer_expr_inner(e, &Expectation::none(), ExprIsRead::Yes));

let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect, ExprIsRead::Yes));

match (range_type, lhs_ty, rhs_ty) {

(RangeOp::Exclusive, None, None) => match self.resolve_range_full() {

None => self.err_ty(),

},

(RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {

None => self.err_ty(),

},

(RangeOp::Inclusive, None, Some(ty)) => {

match self.resolve_range_to_inclusive() {

None => self.err_ty(),

}

}

(RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {

None => self.err_ty(),

},

(RangeOp::Inclusive, Some(_), Some(ty)) => {

match self.resolve_range_inclusive() {

None => self.err_ty(),

}

}

(RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {

None => self.err_ty(),

},

(RangeOp::Inclusive, _, None) => self.err_ty(),

let index_ty = self.infer_expr(*index, &Expectation::none(), ExprIsRead::Yes);

if let Some(index_trait) = self.resolve_lang_trait(LangItem::Index) {

let receiver_adjustments = method_resolution::resolve_indexing_op(

&mut self.table,

canonicalized,

// mutability will be fixed up in `InferenceContext::infer_mut`;

adj.push(Adjustment::borrow(

Mutability::Not,

));

self.write_expr_adj(*base, adj.into_boxed_slice());

if let Some(func) = index_trait

.trait_items(self.db)

.method_by_name(&Name::new_symbol_root(sym::index))

{

self.write_method_resolution(tgt_expr, func, subst);

}

let assoc = self.resolve_ops_index_output();

} else {

self.err_ty()

}

}

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

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

}

}

Expr::Array(array) => self.infer_expr_array(array, expected),

Expr::Literal(lit) => match lit {

Literal::ByteString(bs) => {

let len = consteval::usize_const(

self.db,

self.resolver.krate(),

);

}

self.resolve_lang_item(LangItem::CStr)

.and_then(LangItemTarget::as_struct)

.map_or_else(

|| self.err_ty(),

|strukt| {

},

),

Literal::Int(_v, ty) => match ty {

None => {

let expected_ty = expected.to_option(&mut self.table);

tracing::debug!(?expected_ty);

}

_ => None,

};

}

},

Literal::Uint(_v, ty) => match ty {

None => {

let expected_ty = expected.to_option(&mut self.table);

}

_ => None,

};

}

},

Literal::Float(_v, ty) => match ty {

None => {

}

},

},

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

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

let expected = expected.to_option(&mut self.table).unwrap_or_else(|| self.err_ty());

expected

}

Expr::InlineAsm(asm) => {

let check_expr_asm_operand = |this: &mut Self, expr, is_input: bool| {

let ty = this.infer_expr_no_expect(expr, ExprIsRead::Yes);

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

// function.

if is_input {

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

_ = this.coerce(

expr.into(),

AllowTwoPhase::No,

CoerceNever::Yes,

);

}

_ = this.coerce(

expr.into(),

AllowTwoPhase::No,

CoerceNever::Yes,

);

AsmOperand::Label(expr) => {

self.infer_expr(

expr,

ExprIsRead::No,

);

}

// FIXME: `sym` should report for things that are not functions or statics.

AsmOperand::Sym(_) => (),

});

}

};

// use a new type variable if we got unknown here

let ty = self.insert_type_vars_shallow(ty);

&& self.expr_guaranteed_to_constitute_read_for_never(tgt_expr, is_read)

{

// Any expression that produces a value of type `!` must have diverged

ty

}

let g = self.resolver.update_to_inner_scope(self.db, self.owner, scope_id);

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

Some(ty) => ty,

id: &Option<BlockId>,

statements: &[Statement],

tail: &Option<ExprId>,

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

// FIXME: We should handle async blocks like we handle closures

let expected = &Expectation::has_type(ret_ty);

let (_, inner_ty) = self.with_breakable_ctx(BreakableKind::Border, None, None, |this| {

let ty = this.infer_block(tgt_expr, *id, statements, *tail, None, expected);

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

Err(_) => {

target

}

}

pub(crate) fn lower_async_block_type_impl_trait(

&mut self,

tgt_expr: ExprId,

// Use the first type parameter as the output type of future.

// existential type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType>

let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, tgt_expr);

let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();

}

pub(crate) fn write_fn_trait_method_resolution(

&mut self,

fn_x: FnTrait,

tgt_expr: ExprId,

) {

match fn_x {

FnTrait::FnOnce | FnTrait::AsyncFnOnce => (),

FnTrait::FnMut | FnTrait::AsyncFnMut => {

if adjustments

.last()

.map(|it| matches!(it.kind, Adjust::Borrow(_)))

.unwrap_or(true)

{

// prefer reborrow to move

adjustments.push(Adjustment::borrow(

Mutability::Mut,

))

}

} else {

adjustments.push(Adjustment::borrow(

Mutability::Mut,

));

}

}

FnTrait::Fn | FnTrait::AsyncFn => {

adjustments.push(Adjustment::borrow(

Mutability::Not,

));

}

}

};

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

if let Some(func) = trait_data.method_by_name(&fn_x.method_name()) {

self.write_method_resolution(tgt_expr, func, subst);

}

}

};

let krate = self.resolver.krate();

let (elem_ty, len) = match array {

Array::ElementList { elements, .. } if elements.is_empty() => {

(elem_ty, consteval::usize_const(self.db, Some(0), krate))

}

Array::ElementList { elements, .. } => {

for &expr in elements.iter() {

let cur_elem_ty = self.infer_expr_inner(expr, &expected, ExprIsRead::Yes);

}

(

consteval::usize_const(self.db, Some(elements.len() as u128), krate),

)

}

&Array::Repeat { initializer, repeat } => {

self.infer_expr_coerce(

initializer,

ExprIsRead::Yes,

);

match self.body[repeat] {

Expr::Underscore => {

self.write_expr_ty(repeat, usize);

_ => _ = self.infer_expr(repeat, &Expectation::HasType(usize), ExprIsRead::Yes),

}

}

};

// Try to evaluate unevaluated constant, and insert variable if is not possible.

let len = self.table.insert_const_vars_shallow(len);

}

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

.return_coercion

.as_mut()

.expect("infer_return called outside function body")

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

}

match self.return_coercion {

Some(_) => {

if let Some(expr) = expr {

}

}

}

}

match &self.return_coercion {

Some(return_coercion) => {

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

}

}

}

if let Some(box_id) = self.resolve_boxed_box() {

let table = &mut self.table;

let inner_exp = expected

.and_then(|e| e.as_adt())

.filter(|(e_adt, _)| e_adt == &box_id)

.map(|(_, subts)| {

})

.unwrap_or_else(Expectation::none);

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

} else {

self.err_ty()

}

op: BinaryOp,

rhs: ExprId,

tgt_expr: ExprId,

let lhs_expectation = Expectation::none();

let is_read = if matches!(op, BinaryOp::Assignment { .. }) {

ExprIsRead::Yes

ExprIsRead::No

};

let lhs_ty = self.infer_expr(lhs, &lhs_expectation, is_read);

let trait_func = lang_items_for_bin_op(op).and_then(|(name, lang_item)| {

let trait_id = self.resolve_lang_item(lang_item)?.as_trait()?;

let func = trait_id.trait_items(self.db).method_by_name(&name)?;

Some((trait_id, func))

});

None => {

// HACK: `rhs_ty` is a general inference variable with no clue at all at this

// point. Passing `lhs_ty` as both operands just to check if `lhs_ty` is a builtin

// type applicable to `op`.

// Assume both operands are builtin so we can continue inference. No guarantee

// on the correctness, rustc would complain as necessary lang items don't seem

// to exist anyway.

} else {

self.err_ty()

};

// HACK: We can use this substitution for the function because the function itself doesn't

// have its own generic parameters.

Some(sig) => {

if matches!(op, BinaryOp::CmpOp(..) | BinaryOp::Assignment { .. })

{

self.write_expr_adj(

lhs,

Box::new([Adjustment {

}]),

);

}

if matches!(op, BinaryOp::CmpOp(..))

{

self.write_expr_adj(

rhs,

Box::new([Adjustment {

}]),

);

}

}

None => self.err_ty(),

};

let ret_ty = self.process_remote_user_written_ty(ret_ty);

// use knowledge of built-in binary ops, which can sometimes help inference

builtin_ret

} else {

ret_ty

statements: &[Statement],

tail: Option<ExprId>,

label: Option<LabelId>,

let coerce_ty = expected.coercion_target_type(&mut self.table);

let g = self.resolver.update_to_inner_scope(self.db, self.owner, expr);

let prev_env = block_id.map(|block_id| {

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

let ty = if contains_explicit_ref_binding(this.body, *pat) {

this.infer_expr(

*expr,

target_is_read,

)

} else {

this.infer_expr_coerce(

*expr,

target_is_read,

)

};

origin: DeclOrigin::LocalDecl { has_else: else_branch.is_some() },

};

if let Some(expr) = else_branch {

let previous_diverges =

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

this.infer_expr_coerce(

*expr,

ExprIsRead::Yes,

);

this.diverges = previous_diverges;

} else {

this.infer_expr_coerce(

expr,

ExprIsRead::Yes,

);

}

if this

.coerce(

expr.into(),

AllowTwoPhase::No,

coerce_never,

)

{

this.result.type_mismatches.insert(

expr.into(),

);

}

t

} else {

}

}

});

fn lookup_field(

&mut self,

name: &Name,

let mut private_field = None;

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

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

return name.as_tuple_index().and_then(|idx| {

substs.as_slice().get(idx).copied().map(|ty| {

(

Either::Right(TupleFieldId {

tuple: TupleId(

),

index: idx as u32,

}),

)

})

});

}

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

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

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

},

_ => return None,

};

let is_visible = self.db.field_visibilities(field_id.parent)[field_id.local_id]

.is_visible_from(self.db, self.resolver.module());

if !is_visible {

if private_field.is_none() {

}

return None;

}

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

});

None => {

let (field_id, subst) = private_field?;

let adjustments = autoderef.adjust_steps();

let ty = self.process_remote_user_written_ty(ty);

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

tgt_expr: ExprId,

receiver: ExprId,

name: &Name,

// Field projections don't constitute reads.

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

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

None => {

// no field found, lets attempt to resolve it like a function so that IDE things

// work out while people are typing

let resolved = method_resolution::lookup_method(

self.db,

&canonicalized_receiver,

);

self.push_diagnostic(InferenceDiagnostic::UnresolvedField {

expr: tgt_expr,

name: name.clone(),

method_with_same_name_exists: resolved.is_some(),

});

match resolved {

Some((adjust, func, _)) => {

let (ty, adjustments) = adjust.apply(&mut self.table, receiver_ty);

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

self.check_method_call(

tgt_expr,

&[],

self.db

.value_ty(func.into())

.unwrap()

ty,

expected,

)

tgt_expr: ExprId,

callee: ExprId,

args: &[ExprId],

let callee_ty = self.infer_expr(callee, &Expectation::none(), ExprIsRead::Yes);

let (res, derefed_callee) = loop {

let Some((callee_deref_ty, _)) = derefs.next() else {

};

break (Some(res), callee_deref_ty);

}

};

// if the function is unresolved, we use is_varargs=true to

// suppress the arg count diagnostic here

let (param_tys, ret_ty) = match res {

Some((func, params, ret_ty)) => {

let mut adjustments = derefs.adjust_steps();

if let Some(fn_x) = func {

self.write_fn_trait_method_resolution(

fn_x,

&mut adjustments,

tgt_expr,

);

}

self.add_current_closure_dependency(c.into());

self.deferred_closures.entry(c.into()).or_default().push((

tgt_expr,

));

}

None => {

self.push_diagnostic(InferenceDiagnostic::ExpectedFunction {

call_expr: tgt_expr,

});

}

};

let indices_to_skip = self.check_legacy_const_generics(derefed_callee, args);

&mut self,

tgt_expr: ExprId,

args: &[ExprId],

indices_to_skip: &[u32],

is_varargs: bool,

self.check_call_arguments(

tgt_expr,

indices_to_skip,

is_varargs,

);

}

fn infer_method_call(

receiver: ExprId,

args: &[ExprId],

method_name: &Name,

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

// Don't probe on error type, or on a fully unresolved infer var.

// FIXME: Emit an error if we're probing on an infer var (type annotations needed).

for &arg in args {

return receiver_ty;

}

let resolved = method_resolution::lookup_method(

self.db,

let (ty, adjustments) = adjust.apply(&mut self.table, receiver_ty);

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

let interner = DbInterner::new_with(self.db, None, None);

self.check_method_call(

tgt_expr,

args,

self.db

.value_ty(func.into())

.expect("we have a function def")

ty,

expected,

)

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

// assoc function

None => {

{

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

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

self.push_diagnostic(InferenceDiagnostic::UnresolvedMethodCall {

expr: tgt_expr,

name: method_name.clone(),

assoc_func_with_same_name,

});

let recovered = match assoc_func_with_same_name {

Some(f) => {

let interner = DbInterner::new_with(self.db, None, None);

let f = self

.db

.value_ty(f.into())

.expect("we have a function def")

Some((f, sig, true))

}

None => field_with_same_name_exists.and_then(|field_ty| {

Some((field_ty, callable_sig, false))

}),

};

match recovered {

None => {

for &arg in args.iter() {

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

&mut self,

tgt_expr: ExprId,

args: &[ExprId],

let ((formal_receiver_ty, param_tys), ret_ty, is_varargs) =

None => {

let formal_receiver_ty = self.table.next_ty_var();

let ret_ty = self.table.next_ty_var();

((formal_receiver_ty, Vec::new()), ret_ty, true)

}

};

self.check_call_arguments(tgt_expr, &param_tys, ret_ty, expected, args, &[], is_varargs);

}

/// Generic function that factors out common logic from function calls,

&mut self,

call_expr: ExprId,

// Types (as defined in the *signature* of the target function)

// Expected output from the parent expression or statement

// The expressions for each provided argument

provided_args: &[ExprId],

skip_indices: &[u32],

// Whether the function is variadic, for example when imported from C

c_variadic: bool,

) {

// First, let's unify the formal method signature with the expectation eagerly.

// We use this to guide coercion inference; it's output is "fudged" which means

// any remaining type variables are assigned to new, unrelated variables. This

// is polymorphic) and the expected return type.

// No argument expectations are produced if unification fails.

let origin = ObligationCause::new();

if !ocx.try_evaluate_obligations().is_empty() {

}

// Record all the argument types, with the args

// We introduce a helper function to demand that a given argument satisfy a given input

// This is more complicated than just checking type equality, as arguments could be coerced

// This version writes those types back so further type checking uses the narrowed types

let provided_arg = provided_args[idx];

debug!("checking argument {}: {:?} = {:?}", idx, provided_arg, formal_input_ty);

// We're on the happy path here, so we'll do a more involved check and write back types

// To check compatibility, we'll do 3 things:

// 1. Unify the provided argument with the expected type

// 2. Coerce to the most detailed type that could be coerced

// to, which is `expected_ty` if `rvalue_hint` returns an

// `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.

// Cause selection errors caused by resolving a single argument to point at the

// argument and not the call. This lets us customize the span pointed to in the

// If neither check failed, the types are compatible

match formal_ty_error {

this.table.register_predicates(obligations);

Ok(())

}

&& args_count_matches

{

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

}

}

}

&mut self,

expr: ExprId,

def: GenericDefId,

expr: ExprId,

}

fn report_len_mismatch(

&mut self,

def: GenericDefId,

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

match (param, arg) {

}

let GenericParamId::ConstParamId(const_id) = param_id else {

unreachable!("non-const param ID for const param");

};

}

_ => unreachable!("unmatching param kinds were passed to `provided_kind()`"),

}

fn provided_type_like_const(

&mut self,

arg: TypeLikeConst<'_>,

match arg {

TypeLikeConst::Path(path) => self.ctx.make_path_as_body_const(path, const_ty),

}

}

param_id: GenericParamId,

_param: GenericParamDataRef<'_>,

_infer_args: bool,

// Always create an inference var, even when `infer_args == false`. This helps with diagnostics,

// and I think it's also required in the presence of `impl Trait` (that must be inferred).

}

}

fn report_elided_lifetimes_in_path(

)

}

let generic_predicates =

}

// add obligation for trait implementation, if this is a trait method

CallableDefId::FunctionId(f) => {

if let ItemContainerId::TraitId(trait_) = f.lookup(self.db).container {

// construct a TraitRef

let trait_params_len = generics(self.db, trait_.into()).len();

);

}

}

CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}

}

/// Returns the argument indices to skip.

CallableDefId::FunctionId(f) => f,

_ => return Default::default(),

};

}

// check legacy const parameters

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

continue;

}

let expected = Expectation::none(); // FIXME use actual const ty, when that is lowered correctly

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

// FIXME: evaluate and unify with the const

}

/// Dereferences a single level of immutable referencing.

_ => ty,

}

}

/// Enforces expectations on lhs type and rhs type depending on the operator and returns the

/// output type of the binary op.

// Special-case a single layer of referencing, so that things like `5.0 + &6.0f32` work (See rust-lang/rust#57447).

let lhs = self.deref_ty_if_possible(lhs);

let rhs = self.deref_ty_if_possible(rhs);

let output_ty = match op {

BinaryOp::LogicOp(_) => {

bool_

}

BinaryOp::ArithOp(_) => {

// LHS, RHS, and result will have the same type

lhs

}

BinaryOp::CmpOp(_) => {

// LHS and RHS will have the same type

}

BinaryOp::Assignment { op: None } => {

BinaryOp::Assignment { .. } => unreachable!("handled above"),

};

}

// Special-case a single layer of referencing, so that things like `5.0 + &6.0f32` work (See rust-lang/rust#57447).

let lhs = self.deref_ty_if_possible(lhs);

let rhs = self.deref_ty_if_possible(rhs);

BinaryOp::ArithOp(ArithOp::BitAnd | ArithOp::BitOr | ArithOp::BitXor) => {

lhs.is_integral() && rhs.is_integral()

|| lhs.is_floating_point() && rhs.is_floating_point()

}

BinaryOp::CmpOp(_) => {

let is_scalar = |kind| {

matches!(

kind,

| TyKind::FnDef(..)

)

};

}

BinaryOp::Assignment { op: None } => {

pub(super) fn with_breakable_ctx<T>(

&mut self,

kind: BreakableKind,

label: Option<LabelId>,

cb: impl FnOnce(&mut Self) -> T,

self.breakables.push({

});

let res = cb(self);

let ctx = self.breakables.pop().expect("breakable stack broken");

}

}