+ Array, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm, Pat, PatId,

+ RecordLitField,

+ lang_item::{LangItem, LangItemTarget},

+ path::Path,

+use hir_expand::name::Name;

+ consteval::ConstEvalError, db::HirDatabase, display::HirDisplay, infer::TypeMismatch,

+ inhabitedness::is_ty_uninhabited_from, layout::layout_of_ty, mapping::ToChalk, static_lifetime,

+ utils::generics, Adjust, Adjustment, AutoBorrow, CallableDefId, TyBuilder, TyExt,

+mod as_place;

+

+ /// `None` for loops that are not terminating

+ end: Option<BasicBlockId>,

+ UnresolvedName(String),

+ RecordLiteralWithoutPath,

+ UnresolvedMethod,

+ UnresolvedField,

+ TypeMismatch(TypeMismatch),

+ /// This should be never happen. Type mismatch should catch everything.

+ /// Something that should never happen and is definitely a bug, but we don't want to panic if it happened

+ ImplementationError(&'static str),

+ LangItemNotFound(LangItem),

+ MutatingRvalue,

+macro_rules! implementation_error {

+ ($x: expr) => {{

+ ::stdx::never!("MIR lower implementation bug: {}", $x);

+ return Err(MirLowerError::ImplementationError($x));

+ }};

+}

+

+impl MirLowerError {

+ fn unresolved_path(db: &dyn HirDatabase, p: &Path) -> Self {

+ Self::UnresolvedName(p.display(db).to_string())

+ }

+}

+

+ implementation_error!("unsized temporaries");

+ Ok(self.result.locals.alloc(Local { ty }))

+ ) -> Result<Option<(Operand, BasicBlockId)>> {

+ return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));

+ let Some((p, current)) = self.lower_expr_as_place(current, expr_id, true)? else {

+ return Ok(None);

+ };

+ Ok(Some((Operand::Copy(p), current)))

+ fn lower_expr_to_place_with_adjust(

+ place: Place,

+ current: BasicBlockId,

+ adjustments: &[Adjustment],

+ ) -> Result<Option<BasicBlockId>> {

+ match adjustments.split_last() {

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

+ Adjust::NeverToAny => {

+ let temp = self.temp(TyKind::Never.intern(Interner))?;

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

+ }

+ Adjust::Deref(_) => {

+ let Some((p, current)) = self.lower_expr_as_place_with_adjust(current, expr_id, true, adjustments)? else {

+ return Ok(None);

+ };

+ self.push_assignment(current, place, Operand::Copy(p).into(), expr_id.into());

+ Ok(Some(current))

+ }

+ Adjust::Borrow(AutoBorrow::Ref(m) | AutoBorrow::RawPtr(m)) => {

+ let Some((p, current)) = self.lower_expr_as_place_with_adjust(current, expr_id, true, rest)? else {

+ return Ok(None);

+ };

+ let bk = BorrowKind::from_chalk(*m);

+ self.push_assignment(current, place, Rvalue::Ref(bk, p), expr_id.into());

+ Ok(Some(current))

+ }

+ Adjust::Pointer(cast) => {

+ let Some((p, current)) = self.lower_expr_as_place_with_adjust(current, expr_id, true, rest)? else {

+ return Ok(None);

+ };

+ self.push_assignment(

+ current,

+ place,

+ Rvalue::Cast(

+ CastKind::Pointer(cast.clone()),

+ Operand::Copy(p).into(),

+ last.target.clone(),

+ ),

+ expr_id.into(),

+ );

+ Ok(Some(current))

+ }

+ },

+ None => self.lower_expr_to_place_without_adjust(expr_id, place, current),

+ ) -> Result<Option<BasicBlockId>> {

+ if let Some(adjustments) = self.infer.expr_adjustments.get(&expr_id) {

+ return self.lower_expr_to_place_with_adjust(expr_id, place, prev_block, adjustments);

+ ) -> Result<Option<BasicBlockId>> {

+ let unresolved_name = || MirLowerError::unresolved_path(self.db, p);

+ .ok_or_else(unresolved_name)?;

+ if let Some(assoc) = self

+ match assoc.0 {

+ hir_def::AssocItemId::ConstId(c) => {

+ self.lower_const(c, current, place, expr_id.into())?;

+ return Ok(Some(current))

+ },

+ _ => not_supported!("associated functions and types"),

+ }

+ } else if let Some(variant) = self

+ .infer

+ .variant_resolution_for_expr(expr_id)

+ {

+ match variant {

+ VariantId::EnumVariantId(e) => ValueNs::EnumVariantId(e),

+ VariantId::StructId(s) => ValueNs::StructId(s),

+ VariantId::UnionId(_) => implementation_error!("Union variant as path"),

+ }

+ } else {

+ return Err(unresolved_name());

+ }

+ Operand::Copy(self.result.binding_locals[pat_id].into()).into(),

+ expr_id.into(),

+ Ok(Some(current))

+ }

+ ValueNs::ConstId(const_id) => {

+ self.lower_const(const_id, current, place, expr_id.into())?;

+ Ok(Some(current))

+ let current = self.lower_enum_variant(

+ variant_id,

+ current,

+ place,

+ ty,

+ vec![],

+ expr_id.into(),

+ )?;

+ Ok(Some(current))

+ expr_id.into(),

+ Ok(Some(current))

+ Ok(Some(current))

+ let Some((discr, current)) = self.lower_expr_to_some_operand(*condition, current)? else {

+ return Ok(None);

+ };

+ let start_of_else = self.new_basic_block();

+ let end_of_else = if let Some(else_branch) = else_branch {

+ self.lower_expr_to_place(*else_branch, place, start_of_else)?

+ } else {

+ Some(start_of_else)

+ };

+ Ok(self.merge_blocks(end_of_then, end_of_else))

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

+ return Ok(None);

+ };

+ self.expr_ty_after_adjustments(*expr),

+ self.write_bytes_to_place(

+ then_target,

+ place.clone(),

+ vec![1],

+ TyBuilder::bool(),

+ MirSpan::Unknown,

+ )?;

+ self.write_bytes_to_place(

+ else_target,

+ place,

+ vec![0],

+ TyBuilder::bool(),

+ MirSpan::Unknown,

+ )?;

+ Ok(self.merge_blocks(Some(then_target), else_target))

+ Expr::Loop { body, label } => self.lower_loop(current, *label, |this, begin| {

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

+ this.set_goto(block, begin);

+ }

+ self.lower_loop(current, *label, |this, begin| {

+ let Some((discr, to_switch)) = this.lower_expr_to_some_operand(*condition, begin)? else {

+ return Ok(());

+ };

+ let end = this.current_loop_end()?;

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

+ this.set_goto(block, begin);

+ }

+ &Expr::For { iterable, pat, body, label } => {

+ let into_iter_fn = self.resolve_lang_item(LangItem::IntoIterIntoIter)?

+ .as_function().ok_or(MirLowerError::LangItemNotFound(LangItem::IntoIterIntoIter))?;

+ let iter_next_fn = self.resolve_lang_item(LangItem::IteratorNext)?

+ .as_function().ok_or(MirLowerError::LangItemNotFound(LangItem::IteratorNext))?;

+ let option_some = self.resolve_lang_item(LangItem::OptionSome)?

+ .as_enum_variant().ok_or(MirLowerError::LangItemNotFound(LangItem::OptionSome))?;

+ let option = option_some.parent;

+ let into_iter_fn_op = Operand::const_zst(

+ TyKind::FnDef(

+ self.db.intern_callable_def(CallableDefId::FunctionId(into_iter_fn)).into(),

+ Substitution::from1(Interner, self.expr_ty(iterable))

+ ).intern(Interner));

+ let iter_next_fn_op = Operand::const_zst(

+ TyKind::FnDef(

+ self.db.intern_callable_def(CallableDefId::FunctionId(iter_next_fn)).into(),

+ Substitution::from1(Interner, self.expr_ty(iterable))

+ ).intern(Interner));

+ let &Some(iterator_ty) = &self.infer.type_of_for_iterator.get(&expr_id) else {

+ return Err(MirLowerError::TypeError("unknown for loop iterator type"));

+ };

+ 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 iterator_place: Place = self.temp(iterator_ty.clone())?.into();

+ let option_item_place: Place = self.temp(option_item_ty.clone())?.into();

+ let ref_mut_iterator_place: Place = self.temp(ref_mut_iterator_ty)?.into();

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

+ else {

+ return Ok(None);

+ };

+ self.push_assignment(current, ref_mut_iterator_place.clone(), Rvalue::Ref(BorrowKind::Mut { allow_two_phase_borrow: false }, iterator_place), expr_id.into());

+ self.lower_loop(current, label, |this, begin| {

+ let Some(current) = this.lower_call(iter_next_fn_op, vec![Operand::Copy(ref_mut_iterator_place)], option_item_place.clone(), begin, false)?

+ else {

+ return Ok(());

+ };

+ let end = this.current_loop_end()?;

+ let (current, _) = this.pattern_matching_variant(

+ option_item_ty.clone(),

+ BindingAnnotation::Unannotated,

+ option_item_place.into(),

+ option_some.into(),

+ current,

+ pat.into(),

+ Some(end),

+ &[pat], &None)?;

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

+ this.set_goto(block, begin);

+ }

+ Ok(())

+ })

+ },

+ let callee_ty = self.expr_ty_after_adjustments(*callee);

+ self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id))

+ self.infer.method_resolution(expr_id).ok_or(MirLowerError::UnresolvedMethod)?;

+ self.lower_call_and_args(

+ self.is_uninhabited(expr_id),

+ let Some((cond_place, mut current)) = self.lower_expr_as_place(current, *expr, true)?

+ else {

+ return Ok(None);

+ };

+ let cond_ty = self.expr_ty_after_adjustments(*expr);

+ let mut end = None;

+ if let Some(block) = self.lower_expr_to_place(*expr, place.clone(), then)? {

+ let r = end.get_or_insert_with(|| self.new_basic_block());

+ self.set_goto(block, *r);

+ }

+ Ok(None)

+ let end =

+ self.current_loop_end()?;

+ self.set_goto(current, end);

+ Ok(None)

+ if let Some(c) = self.lower_expr_to_place(*expr, return_slot().into(), current)? {

+ current = c;

+ } else {

+ return Ok(None);

+ }

+ Ok(None)

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

+ .ok_or_else(|| match path {

+ Some(p) => MirLowerError::UnresolvedName(p.display(self.db).to_string()),

+ None => MirLowerError::RecordLiteralWithoutPath,

+ })?;

+ variant_data.field(name).ok_or(MirLowerError::UnresolvedField)?;

+ let Some((op, c)) = self.lower_expr_to_some_operand(*expr, current)? else {

+ return Ok(None);

+ };

+ current = c;

+ expr_id.into(),

+ Ok(Some(current))

+ variant_data.field(name).ok_or(MirLowerError::UnresolvedField)?;

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

+ return Ok(None);

+ };

+ expr_id.into(),

+ Ok(Some(current))

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

+ return Ok(None);

+ };

+ self.push_assignment(current, place, Rvalue::Ref(bk, p), expr_id.into());

+ Ok(Some(current))

+ Expr::Field { .. } | Expr::Index { .. } | Expr::UnaryOp { op: hir_def::expr::UnaryOp::Deref, .. } => {

+ let Some((p, current)) = self.lower_expr_as_place(current, expr_id, true)? else {

+ return Ok(None);

+ };

+ self.push_assignment(current, place, Operand::Copy(p).into(), expr_id.into());

+ Ok(Some(current))

+ }

+ Expr::UnaryOp { expr, op: op @ (hir_def::expr::UnaryOp::Not | hir_def::expr::UnaryOp::Neg) } => {

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

+ return Ok(None);

+ };

+ let operation = match op {

+ hir_def::expr::UnaryOp::Not => UnOp::Not,

+ hir_def::expr::UnaryOp::Neg => UnOp::Neg,

+ _ => unreachable!(),

+ };

+ self.push_assignment(

+ current,

+ place,

+ Rvalue::UnaryOp(operation, operand),

+ expr_id.into(),

+ );

+ Ok(Some(current))

+ let Some((lhs_place, current)) =

+ self.lower_expr_as_place(current, *lhs, false)?

+ else {

+ return Ok(None);

+ let Some((rhs_op, current)) = self.lower_expr_to_some_operand(*rhs, current)? else {

+ return Ok(None);

+ };

+ self.push_assignment(current, lhs_place, rhs_op.into(), expr_id.into());

+ return Ok(Some(current));

+ let Some((lhs_op, current)) = self.lower_expr_to_some_operand(*lhs, current)? else {

+ return Ok(None);

+ };

+ let Some((rhs_op, current)) = self.lower_expr_to_some_operand(*rhs, current)? else {

+ return Ok(None);

+ };

+ expr_id.into(),

+ Ok(Some(current))

+ let Some(values) = exprs

+ let Some((o, c)) = self.lower_expr_to_some_operand(*x, current)? else {

+ return Ok(None);

+ };

+ current = c;

+ Ok(Some(o))

+ .collect::<Result<Option<_>>>()?

+ else {

+ return Ok(None);

+ };

+ let r = Rvalue::Aggregate(

+ AggregateKind::Tuple(self.expr_ty(expr_id)),

+ values,

+ self.push_assignment(current, place, r, expr_id.into());

+ Ok(Some(current))

+ let Some(values) = elements

+ let Some((o, c)) = self.lower_expr_to_some_operand(*x, current)? else {

+ return Ok(None);

+ };

+ current = c;

+ Ok(Some(o))

+ .collect::<Result<Option<_>>>()?

+ else {

+ return Ok(None);

+ };

+ let r = Rvalue::Aggregate(

+ AggregateKind::Array(elem_ty),

+ values,

+ self.push_assignment(current, place, r, expr_id.into());

+ Ok(Some(current))

+ self.push_assignment(current, place, op.into(), expr_id.into());

+ Ok(Some(current))

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

+ let index = name

+ .as_tuple_index()

+ .ok_or(MirLowerError::TypeError("named field on tuple"))?;

+ place.projection.push(ProjectionElem::TupleField(index))

+ } else {

+ let field =

+ self.infer.field_resolution(expr_id).ok_or(MirLowerError::UnresolvedField)?;

+ place.projection.push(ProjectionElem::Field(field));

+ } else {

+ not_supported!("")

+ Ok(())

+ span: MirSpan,

+ ) -> Result<()> {

+ self.write_const_to_place(c, prev_block, place, span)

+ span: MirSpan,

+ ) -> Result<()> {

+ self.push_assignment(prev_block, place, Operand::Constant(c).into(), span);

+ Ok(())

+ span: MirSpan,

+ ) -> Result<()> {

+ self.push_assignment(prev_block, place, Operand::from_bytes(cv, ty).into(), span);

+ Ok(())

+ span: MirSpan,

+ span,

+ fn lower_call_and_args(

+ is_uninhabited: bool,

+ ) -> Result<Option<BasicBlockId>> {

+ let Some(args) = args

+ if let Some((temp, c)) = self.lower_expr_to_some_operand(arg, current)? {

+ current = c;

+ Ok(Some(temp))

+ } else {

+ Ok(None)

+ }

+ .collect::<Result<Option<Vec<_>>>>()?

+ else {

+ return Ok(None);

+ };

+ self.lower_call(func, args, place, current, is_uninhabited)

+ }

+

+ fn lower_call(

+ &mut self,

+ func: Operand,

+ args: Vec<Operand>,

+ place: Place,

+ current: BasicBlockId,

+ is_uninhabited: bool,

+ ) -> Result<Option<BasicBlockId>> {

+ let b = if is_uninhabited { None } else { Some(self.new_basic_block()) };

+ target: b,

+ fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty {

+ let mut ty = None;

+ if let Some(x) = self.infer.expr_adjustments.get(&e) {

+ if let Some(x) = x.last() {

+ ty = Some(x.target.clone());

+ }

+ }

+ ty.unwrap_or_else(|| self.expr_ty(e))

+ }

+

+ fn push_statement(&mut self, block: BasicBlockId, statement: Statement) {

+ self.result.basic_blocks[block].statements.push(statement);

+ }

+

+ fn push_assignment(

+ &mut self,

+ block: BasicBlockId,

+ place: Place,

+ rvalue: Rvalue,

+ span: MirSpan,

+ ) {

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

+ Pat::Or(pats) => {

+ let then_target = self.new_basic_block();

+ let mut finished = false;

+ for pat in &**pats {

+ let (next, next_else) = self.pattern_match(

+ current,

+ None,

+ cond_place.clone(),

+ cond_ty.clone(),

+ *pat,

+ binding_mode,

+ )?;

+ self.set_goto(next, then_target);

+ match next_else {

+ Some(t) => {

+ current = t;

+ }

+ None => {

+ finished = true;

+ break;

+ }

+ }

+ }

+ (then_target, (!finished).then_some(current))

+ }

+ Pat::Path(_) => {

+ let Some(variant) = self.infer.variant_resolution_for_pat(pattern) else {

+ not_supported!("unresolved variant");

+ };

+ self.pattern_matching_variant(

+ cond_ty,

+ binding_mode,

+ cond_place,

+ variant,

+ current,

+ pattern.into(),

+ current_else,

+ &[],

+ &None,

+ )?

+ }

+ Pat::Bind { id, subpat } => {

+ let target_place = self.result.binding_locals[*id];

+ let mode = self.body.bindings[*id].mode;

+ binding_mode = mode;

+ self.push_storage_live(*id, current)?;

+ pattern.into(),

+ self.pattern_matching_variant(

+ cond_ty,

+ binding_mode,

+ cond_place,

+ variant,

+ current,

+ pattern.into(),

+ current_else,

+ args,

+ ellipsis,

+ )?

+ fn pattern_matching_variant(

+ &mut self,

+ mut cond_ty: Ty,

+ mut binding_mode: BindingAnnotation,

+ mut cond_place: Place,

+ variant: VariantId,

+ current: BasicBlockId,

+ span: MirSpan,

+ current_else: Option<BasicBlockId>,

+ args: &[PatId],

+ ellipsis: &Option<usize>,

+ ) -> Result<(BasicBlockId, Option<BasicBlockId>)> {

+ pattern_matching_dereference(&mut cond_ty, &mut binding_mode, &mut cond_place);

+ let subst = match cond_ty.kind(Interner) {

+ TyKind::Adt(_, s) => s,

+ _ => return Err(MirLowerError::TypeError("non adt type matched with tuple struct")),

+ };

+ let fields_type = self.db.field_types(variant);

+ Ok(match variant {

+ VariantId::EnumVariantId(v) => {

+ let e = self.db.const_eval_discriminant(v)? as u128;

+ let next = self.new_basic_block();

+ let tmp = self.discr_temp_place();

+ self.push_assignment(

+ current,

+ tmp.clone(),

+ Rvalue::Discriminant(cond_place.clone()),

+ span,

+ );

+ let else_target = current_else.unwrap_or_else(|| self.new_basic_block());

+ self.set_terminator(

+ current,

+ Terminator::SwitchInt {

+ discr: Operand::Copy(tmp),

+ targets: SwitchTargets::static_if(e, next, else_target),

+ },

+ );

+ let enum_data = self.db.enum_data(v.parent);

+ let fields =

+ enum_data.variants[v.local_id].variant_data.fields().iter().map(|(x, _)| {

+ (

+ PlaceElem::Field(FieldId { parent: v.into(), local_id: x }),

+ fields_type[x].clone().substitute(Interner, subst),

+ )

+ });

+ self.pattern_match_tuple_like(

+ next,

+ Some(else_target),

+ args.iter().zip(fields).map(|(x, y)| (y.0, *x, y.1)),

+ *ellipsis,

+ &cond_place,

+ binding_mode,

+ )?

+ }

+ VariantId::StructId(s) => {

+ let struct_data = self.db.struct_data(s);

+ let fields = struct_data.variant_data.fields().iter().map(|(x, _)| {

+ (

+ PlaceElem::Field(FieldId { parent: s.into(), local_id: x }),

+ fields_type[x].clone().substitute(Interner, subst),

+ )

+ });

+ self.pattern_match_tuple_like(

+ current,

+ current_else,

+ args.iter().zip(fields).map(|(x, y)| (y.0, *x, y.1)),

+ *ellipsis,

+ &cond_place,

+ binding_mode,

+ )?

+ }

+ VariantId::UnionId(_) => {

+ return Err(MirLowerError::TypeError("pattern matching on union"))

+ }

+ })

+ }

+

+ f: impl FnOnce(&mut MirLowerCtx<'_>, BasicBlockId) -> Result<()>,

+ ) -> Result<Option<BasicBlockId>> {

+ let prev =

+ mem::replace(&mut self.current_loop_blocks, Some(LoopBlocks { begin, end: None }));

+ f(self, begin)?;

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

+ .ok_or(MirLowerError::ImplementationError("current_loop_blocks is corrupt"))?;

+ Ok(my.end)

+

+ fn merge_blocks(

+ &mut self,

+ b1: Option<BasicBlockId>,

+ b2: Option<BasicBlockId>,

+ ) -> Option<BasicBlockId> {

+ match (b1, b2) {

+ (None, None) => None,

+ (None, Some(b)) | (Some(b), None) => Some(b),

+ (Some(b1), Some(b2)) => {

+ let bm = self.new_basic_block();

+ self.set_goto(b1, bm);

+ self.set_goto(b2, bm);

+ Some(bm)

+ }

+ }

+ }

+

+ fn current_loop_end(&mut self) -> Result<BasicBlockId> {

+ let r = match self

+ .current_loop_blocks

+ .as_mut()

+ .ok_or(MirLowerError::ImplementationError("Current loop access out of loop"))?

+ .end

+ {

+ Some(x) => x,

+ None => {

+ let s = self.new_basic_block();

+ self.current_loop_blocks

+ .as_mut()

+ .ok_or(MirLowerError::ImplementationError("Current loop access out of loop"))?

+ .end = Some(s);

+ s

+ }

+ };

+ Ok(r)

+ }

+

+ fn is_uninhabited(&self, expr_id: ExprId) -> bool {

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

+ }

+

+ /// This function push `StorageLive` statements for each binding in the pattern.

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

+ // Current implementation is wrong. It adds no `StorageDead` at the end of scope, and before each break

+ // and continue. It just add a `StorageDead` before the `StorageLive`, which is not wrong, but unneeeded in

+ // the proper implementation. Due this limitation, implementing a borrow checker on top of this mir will falsely

+ // allow this:

+ //

+ // ```

+ // let x;

+ // loop {

+ // let y = 2;

+ // x = &y;

+ // if some_condition {

+ // break; // we need to add a StorageDead(y) above this to kill the x borrow

+ // }

+ // }

+ // use(x)

+ // ```

+ // But I think this approach work for mutability analysis, as user can't write code which mutates a binding

+ // after StorageDead, except loops, which are handled by this hack.

+ let span = self.body.bindings[b]

+ .definitions

+ .first()

+ .copied()

+ .map(MirSpan::PatId)

+ .unwrap_or(MirSpan::Unknown);

+ let l = self.result.binding_locals[b];

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

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

+ Ok(())

+ }

+

+ fn resolve_lang_item(&self, item: LangItem) -> Result<LangItemTarget> {

+ let crate_id = self.owner.module(self.db.upcast()).krate();

+ self.db.lang_item(crate_id, item).ok_or(MirLowerError::LangItemNotFound(item))

+ }

+

+ fn lower_block_to_place(

+ &mut self,

+ label: Option<LabelId>,

+ statements: &[hir_def::expr::Statement],

+ mut current: BasicBlockId,

+ tail: Option<ExprId>,

+ place: Place,

+ ) -> Result<Option<Idx<BasicBlock>>> {

+ if label.is_some() {

+ not_supported!("block with label");

+ }

+ for statement in statements.iter() {

+ match statement {

+ hir_def::expr::Statement::Let { pat, initializer, else_branch, type_ref: _ } => {

+ if let Some(expr_id) = initializer {

+ let else_block;

+ let Some((init_place, c)) =

+ self.lower_expr_as_place(current, *expr_id, true)?

+ else {

+ return Ok(None);

+ };

+ current = c;

+ (current, else_block) = self.pattern_match(

+ current,

+ None,

+ init_place,

+ self.expr_ty_after_adjustments(*expr_id),

+ *pat,

+ BindingAnnotation::Unannotated,

+ )?;

+ match (else_block, else_branch) {

+ (None, _) => (),

+ (Some(else_block), None) => {

+ self.set_terminator(else_block, Terminator::Unreachable);

+ }

+ (Some(else_block), Some(else_branch)) => {

+ if let Some((_, b)) =

+ self.lower_expr_as_place(else_block, *else_branch, true)?

+ {

+ self.set_terminator(b, Terminator::Unreachable);

+ }

+ }

+ }

+ }

+ }

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

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

+ return Ok(None);

+ };

+ current = c;

+ }

+ }

+ }

+ match tail {

+ Some(tail) => self.lower_expr_to_place(tail, place, current),

+ None => Ok(Some(current)),

+ }

+ }

+ let _p = profile::span("mir_body_query").detail(|| match def {

+ DefWithBodyId::FunctionId(it) => db.function_data(it).name.to_string(),

+ DefWithBodyId::StaticId(it) => db.static_data(it).name.clone().to_string(),

+ DefWithBodyId::ConstId(it) => {

+ db.const_data(it).name.clone().unwrap_or_else(Name::missing).to_string()

+ }

+ DefWithBodyId::VariantId(it) => {

+ db.enum_data(it.parent).variants[it.local_id].name.to_string()

+ }

+ });

+ let result = lower_to_mir(db, def, &body, &infer, body.body_expr)?;

+ Ok(Arc::new(result))

+ if let Some((_, x)) = infer.type_mismatches().next() {

+ return Err(MirLowerError::TypeMismatch(x.clone()));

+ }

+ locals.alloc(Local { ty: infer[root_expr].clone() });

+ let mut binding_locals: ArenaMap<BindingId, LocalId> = ArenaMap::new();

+ let param_locals: Vec<LocalId> = if let DefWithBodyId::FunctionId(fid) = owner {

+ let substs = TyBuilder::placeholder_subst(db, fid);

+ let callable_sig = db.callable_item_signature(fid.into()).substitute(Interner, &substs);

+ body.params

+ .iter()

+ .zip(callable_sig.params().iter())

+ .map(|(&x, ty)| {

+ let local_id = locals.alloc(Local { ty: ty.clone() });

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

+ if matches!(

+ body.bindings[id].mode,

+ BindingAnnotation::Unannotated | BindingAnnotation::Mutable

+ ) {

+ binding_locals.insert(id, local_id);

+ }

+ }

+ local_id

+ })

+ .collect()

+ } else {

+ if !body.params.is_empty() {

+ return Err(MirLowerError::TypeError("Unexpected parameter for non function body"));

+ }

+ vec![]

+ };

+ for (id, _) in body.bindings.iter() {

+ if !binding_locals.contains_idx(id) {

+ binding_locals.insert(id, locals.alloc(Local { ty: infer[id].clone() }));

+ let mir = MirBody {

+ basic_blocks,

+ locals,

+ start_block,

+ binding_locals,

+ param_locals,

+ owner,

+ arg_count: body.params.len(),

+ };

+ let mut current = start_block;

+ for (&param, local) in body.params.iter().zip(ctx.result.param_locals.clone().into_iter()) {

+ if let Pat::Bind { id, .. } = body[param] {

+ if local == ctx.result.binding_locals[id] {

+ continue;

+ }

+ }

+ let r = ctx.pattern_match(

+ current,

+ None,

+ local.into(),

+ ctx.result.locals[local].ty.clone(),

+ param,

+ BindingAnnotation::Unannotated,

+ )?;

+ if let Some(b) = r.1 {

+ ctx.set_terminator(b, Terminator::Unreachable);

+ }

+ current = r.0;

+ }

+ if let Some(b) = ctx.lower_expr_to_place(root_expr, return_slot().into(), current)? {

+ ctx.result.basic_blocks[b].terminator = Some(Terminator::Return);

+ }