lang_item::{LangItem, LangItemTarget},

path::Path,

resolver::{resolver_for_expr, ResolveValueResult, ValueNs},

};

use hir_expand::name::Name;

use la_arena::ArenaMap;

inhabitedness::is_ty_uninhabited_from,

layout::{layout_of_ty, LayoutError},

mapping::ToChalk,

static_lifetime,

utils::{generics, ClosureSubst},

Adjust, Adjustment, AutoBorrow, CallableDefId, TyBuilder, TyExt,

place: Place,

}

struct MirLowerCtx<'a> {

result: MirBody,

owner: DefWithBodyId,

current_loop_blocks: Option<LoopBlocks>,

labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>,

discr_temp: Option<Place>,

db: &'a dyn HirDatabase,

body: &'a Body,

infer: &'a InferenceResult,

}

#[derive(Debug, Clone, PartialEq, Eq)]

binding_locals,

param_locals: vec![],

owner,

closures: vec![],

};

let ctx = MirLowerCtx {

current_loop_blocks: None,

labeled_loop_blocks: Default::default(),

discr_temp: None,

};

ctx

}

if matches!(ty.kind(Interner), TyKind::Slice(_) | TyKind::Dyn(_)) {

implementation_error!("unsized temporaries");

}

}

fn lower_expr_to_some_operand(

match adjustments.split_last() {

Some((last, rest)) => match &last.kind {

Adjust::NeverToAny => {

self.lower_expr_to_place_with_adjust(expr_id, temp.into(), current, rest)

}

Adjust::Deref(_) => {

Err(MirLowerError::IncompleteExpr)

},

Expr::Path(p) => {

}

}

};

match pr {

ValueNs::LocalBinding(_) | ValueNs::StaticId(_) => {

Ok(Some(current))

}

ValueNs::ConstId(const_id) => {

Ok(Some(current))

}

ValueNs::EnumVariantId(variant_id) => {

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

if let Some(label) = label {

self.lower_loop(current, place.clone(), Some(*label), expr_id.into(), |this, begin| {

let end = this.current_loop_end()?;

}

Ok(())

})

}

}

Expr::Loop { body, label } => self.lower_loop(current, place, *label, expr_id.into(), |this, begin| {

}

Ok(())

}),

expr_id.into(),

);

if let Some((_, block)) = this.lower_expr_as_place(after_cond, *body, true)? {

this.set_goto(block, begin, expr_id.into());

}

Ok(())

let ref_mut_iterator_ty = TyKind::Ref(Mutability::Mut, static_lifetime(), iterator_ty.clone()).intern(Interner);

let item_ty = &self.infer.type_of_pat[pat];

let option_item_ty = TyKind::Adt(chalk_ir::AdtId(option.into()), Substitution::from1(Interner, item_ty.clone())).intern(Interner);

let Some(current) = self.lower_call_and_args(into_iter_fn_op, Some(iterable).into_iter(), iterator_place.clone(), current, false, expr_id.into())?

else {

return Ok(None);

AdtPatternShape::Tuple { args: &[pat], ellipsis: None },

)?;

if let Some((_, block)) = this.lower_expr_as_place(current, body, true)? {

this.set_goto(block, begin, expr_id.into());

}

Ok(())

return Ok(None);

}

}

self.set_terminator(current, TerminatorKind::Return, expr_id.into());

Ok(None)

}

Expr::Await { .. } => not_supported!("await"),

Expr::Yeet { .. } => not_supported!("yeet"),

Expr::Async { .. } => not_supported!("async block"),

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

let Some((x, current)) = self.lower_expr_to_some_operand(*expr, current)? else {

return Ok(None);

},

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

let op = op.ok_or(MirLowerError::IncompleteExpr)?;

// Without adjust here is a hack. We assume that we know every possible adjustment

// for binary operator, and use without adjust to simplify our conditions.

let lhs_ty = self.expr_ty_without_adjust(*lhs);

let rhs_ty = self.expr_ty_without_adjust(*rhs);

let builtin_inequal_impls = matches!(

op,

BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) | BinaryOp::Assignment { op: Some(ArithOp::Shl | ArithOp::Shr) }

ProjectionElem::Deref => ProjectionElem::Deref,

ProjectionElem::Field(x) => ProjectionElem::Field(x),

ProjectionElem::TupleOrClosureField(x) => ProjectionElem::TupleOrClosureField(x),

ProjectionElem::OpaqueCast(x) => ProjectionElem::OpaqueCast(x),

ProjectionElem::Index(x) => match x { },

}

};

match &capture.kind {

CaptureKind::ByRef(bk) => {

let tmp_ty = capture.ty.clone().substitute(Interner, &placeholder_subst);

self.push_assignment(

current,

tmp.clone(),

}

}

fn push_field_projection(&self, place: &mut Place, expr_id: ExprId) -> Result<()> {

if let Expr::Field { expr, name } = &self.body[expr_id] {

if let TyKind::Tuple(..) = self.expr_ty_after_adjustments(*expr).kind(Interner) {

fn lower_const(

&mut self,

prev_block: BasicBlockId,

place: Place,

subst: Substitution,

// We can't evaluate constant with substitution now, as generics are not monomorphized in lowering.

intern_const_scalar(ConstScalar::UnevaluatedConst(const_id, subst), ty)

} else {

self.db

.const_eval(const_id.into(), subst)

.map_err(|e| MirLowerError::ConstEvalError(name, Box::new(e)))?

self.push_statement(block, StatementKind::Assign(place, rvalue).with_span(span));

}

match &self.discr_temp {

Some(x) => x.clone(),

None => {

self.discr_temp = Some(tmp.clone());

tmp

}

None

};

self.set_goto(prev_block, begin, span);

f(self, begin)?;

let my = mem::replace(&mut self.current_loop_blocks, prev).ok_or(

MirLowerError::ImplementationError("current_loop_blocks is corrupt".to_string()),

is_ty_uninhabited_from(&self.infer[expr_id], self.owner.module(self.db.upcast()), self.db)

}

fn push_storage_live(&mut self, b: BindingId, current: BasicBlockId) -> Result<()> {

let span = self.body.bindings[b]

.definitions

.first()

.map(MirSpan::PatId)

.unwrap_or(MirSpan::Unknown);

let l = self.binding_local(b)?;

self.push_statement(current, StatementKind::StorageDead(l).with_span(span));

self.push_statement(current, StatementKind::StorageLive(l).with_span(span));

Ok(())

}

}

hir_def::hir::Statement::Expr { expr, has_semi: _ } => {

let Some((_, c)) = self.lower_expr_as_place(current, *expr, true)? else {

return Ok(None);

};

}

}

}

let base_param_count = self.result.param_locals.len();

self.result.param_locals.extend(params.clone().map(|(x, ty)| {

let local_id = self.result.locals.alloc(Local { ty });

if let Pat::Bind { id, subpat: None } = self.body[x] {

if matches!(

self.body.bindings[id].mode,

}

}

}

}

fn cast_kind(source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {

};

let (captures, _) = infer.closure_info(&closure);

let mut ctx = MirLowerCtx::new(db, owner, &body, &infer);

// 0 is return local

ctx.result.locals.alloc(Local { ty: infer[*root].clone() });

let Some(sig) = ClosureSubst(substs).sig_ty().callable_sig(db) else {

implementation_error!("closure has not callable sig");

};

args.iter().zip(sig.params().iter()).map(|(x, y)| (*x, y.clone())),

|_| true,

)?;

}

let mut upvar_map: FxHashMap<LocalId, Vec<(&CapturedItem, usize)>> = FxHashMap::default();

for (i, capture) in captures.iter().enumerate() {

}

ctx.lower_params_and_bindings([].into_iter(), binding_picker)?

};

}

Ok(ctx.result)

}