+ data::adt::{StructKind, VariantData},

+ hir::{

+ consteval::ConstEvalError,

+ db::HirDatabase,

+ display::HirDisplay,

+ infer::{CaptureKind, CapturedItem, TypeMismatch},

+ inhabitedness::is_ty_uninhabited_from,

+ layout::layout_of_ty,

+ mapping::ToChalk,

+ static_lifetime,

+ utils::generics,

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

+ labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>,

+ ImplementationError(String),

+ UnresolvedUpvar(Place),

+ UnaccessableLocal,

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

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

+impl<'ctx> MirLowerCtx<'ctx> {

+ fn new(

+ db: &'ctx dyn HirDatabase,

+ owner: DefWithBodyId,

+ body: &'ctx Body,

+ infer: &'ctx InferenceResult,

+ ) -> Self {

+ let mut basic_blocks = Arena::new();

+ let start_block = basic_blocks.alloc(BasicBlock {

+ statements: vec![],

+ terminator: None,

+ is_cleanup: false,

+ });

+ let locals = Arena::new();

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

+ let mir = MirBody {

+ basic_blocks,

+ locals,

+ start_block,

+ binding_locals,

+ param_locals: vec![],

+ owner,

+ arg_count: body.params.len(),

+ closures: vec![],

+ };

+ let ctx = MirLowerCtx {

+ result: mir,

+ db,

+ infer,

+ body,

+ owner,

+ current_loop_blocks: None,

+ labeled_loop_blocks: Default::default(),

+ discr_temp: None,

+ };

+ ctx

+ }

+

+ Operand::Copy(self.binding_local(pat_id)?.into()).into(),

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

+ Some(l) => self.labeled_loop_blocks.get(&l).ok_or(MirLowerError::UnresolvedLabel)?,

+ let Some(c) = self.lower_expr_to_place(expr, loop_data.place.clone(), current)? else {

+ Some(l) => self.labeled_loop_blocks.get(&l).ok_or(MirLowerError::UnresolvedLabel)?.end.expect("We always generate end for labeled loops"),

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

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

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

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

+ if let hir_def::hir::BinaryOp::Assignment { op } = op {

+ hir_def::hir::BinaryOp::LogicOp(op) => match op {

+ hir_def::hir::LogicOp::And => BinOp::BitAnd, // FIXME: make these short circuit

+ hir_def::hir::LogicOp::Or => BinOp::BitOr,

+ hir_def::hir::BinaryOp::ArithOp(op) => BinOp::from(op),

+ hir_def::hir::BinaryOp::CmpOp(op) => BinOp::from(op),

+ hir_def::hir::BinaryOp::Assignment { .. } => unreachable!(), // handled above

+ Expr::Closure { .. } => {

+ let ty = self.expr_ty(expr_id);

+ let TyKind::Closure(id, _) = ty.kind(Interner) else {

+ not_supported!("closure with non closure type");

+ };

+ self.result.closures.push(*id);

+ let (captures, _) = self.infer.closure_info(id);

+ let mut operands = vec![];

+ for capture in captures.iter() {

+ let p = Place {

+ local: self.binding_local(capture.place.local)?,

+ projection: capture.place.projections.clone().into_iter().map(|x| {

+ match x {

+ ProjectionElem::Deref => ProjectionElem::Deref,

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

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

+ ProjectionElem::ConstantIndex { offset, min_length, from_end } => ProjectionElem::ConstantIndex { offset, min_length, from_end },

+ ProjectionElem::Subslice { from, to, from_end } => ProjectionElem::Subslice { from, to, from_end },

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

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

+ }

+ }).collect(),

+ };

+ match &capture.kind {

+ CaptureKind::ByRef(bk) => {

+ let tmp: Place = self.temp(capture.ty.clone())?.into();

+ self.push_assignment(

+ current,

+ tmp.clone(),

+ Rvalue::Ref(bk.clone(), p),

+ expr_id.into(),

+ );

+ operands.push(Operand::Move(tmp));

+ },

+ CaptureKind::ByValue => operands.push(Operand::Move(p)),

+ }

+ }

+ self.push_assignment(

+ current,

+ place,

+ Rvalue::Aggregate(AggregateKind::Closure(ty), operands),

+ expr_id.into(),

+ );

+ Ok(Some(current))

+ },

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

+ hir_def::hir::Literal::String(b) => {

+ hir_def::hir::Literal::ByteString(b) => {

+ hir_def::hir::Literal::Char(c) => u32::from(*c).to_le_bytes().into(),

+ hir_def::hir::Literal::Bool(b) => vec![*b as u8],

+ hir_def::hir::Literal::Int(x, _) => x.to_le_bytes()[0..size].into(),

+ hir_def::hir::Literal::Uint(x, _) => x.to_le_bytes()[0..size].into(),

+ hir_def::hir::Literal::Float(f, _) => match size {

+ self.labeled_loop_blocks

+ .insert(label, self.current_loop_blocks.as_ref().unwrap().clone())

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

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

+ )?;

+ self.labeled_loop_blocks.insert(label.unwrap(), prev);

+ .ok_or(MirLowerError::ImplementationError(

+ "Current loop access out of loop".to_string(),

+ ))?

+ .ok_or(MirLowerError::ImplementationError(

+ "Current loop access out of loop".to_string(),

+ ))?

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

+ let l = self.binding_local(b)?;

+ Ok(())

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

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

+ let mut err = None;

+ if let Err(e) = self.push_storage_live(b, current) {

+ err = Some(e);

+ }

+ if let Some(e) = err {

+ return Err(e);

+ }

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

+

+ fn lower_params_and_bindings(

+ &mut self,

+ params: impl Iterator<Item = (PatId, Ty)> + Clone,

+ pick_binding: impl Fn(BindingId) -> bool,

+ ) -> Result<BasicBlockId> {

+ 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,

+ BindingAnnotation::Unannotated | BindingAnnotation::Mutable

+ ) {

+ self.result.binding_locals.insert(id, local_id);

+ }

+ }

+ local_id

+ }));

+ // and then rest of bindings

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

+ if !pick_binding(id) {

+ continue;

+ }

+ if !self.result.binding_locals.contains_idx(id) {

+ self.result

+ .binding_locals

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

+ }

+ }

+ let mut current = self.result.start_block;

+ for ((param, _), local) in

+ params.zip(self.result.param_locals.clone().into_iter().skip(base_param_count))

+ {

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

+ if local == self.binding_local(id)? {

+ continue;

+ }

+ }

+ let r = self.pattern_match(

+ current,

+ None,

+ local.into(),

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

+ param,

+ BindingAnnotation::Unannotated,

+ )?;

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

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

+ }

+ current = r.0;

+ }

+ Ok(current)

+ }

+

+ fn binding_local(&self, b: BindingId) -> Result<LocalId> {

+ match self.result.binding_locals.get(b) {

+ Some(x) => Ok(*x),

+ None => Err(MirLowerError::UnaccessableLocal),

+ }

+ }

+pub fn mir_body_for_closure_query(

+ db: &dyn HirDatabase,

+ closure: ClosureId,

+) -> Result<Arc<MirBody>> {

+ let (owner, expr) = db.lookup_intern_closure(closure.into());

+ let body = db.body(owner);

+ let infer = db.infer(owner);

+ let Expr::Closure { args, body: root, .. } = &body[expr] else {

+ implementation_error!("closure expression is not closure");

+ };

+ let TyKind::Closure(_, substs) = &infer[expr].kind(Interner) else {

+ implementation_error!("closure expression is not closure");

+ };

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

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

+ ctx.result.arg_count = args.len() + 1;

+ // 0 is return local

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

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

+ let Some(sig) = substs.at(Interner, 0).assert_ty_ref(Interner).callable_sig(db) else {

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

+ };

+ let current = ctx.lower_params_and_bindings(

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

+ |_| true,

+ )?;

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

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

+ }

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

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

+ let local = ctx.binding_local(capture.place.local)?;

+ upvar_map.entry(local).or_default().push((capture, i));

+ }

+ let mut err = None;

+ let closure_local = ctx.result.locals.iter().nth(1).unwrap().0;

+ ctx.result.walk_places(|p| {

+ if let Some(x) = upvar_map.get(&p.local) {

+ let r = x.iter().find(|x| {

+ if p.projection.len() < x.0.place.projections.len() {

+ return false;

+ }

+ for (x, y) in p.projection.iter().zip(x.0.place.projections.iter()) {

+ match (x, y) {

+ (ProjectionElem::Deref, ProjectionElem::Deref) => (),

+ (ProjectionElem::Field(x), ProjectionElem::Field(y)) if x == y => (),

+ (

+ ProjectionElem::TupleOrClosureField(x),

+ ProjectionElem::TupleOrClosureField(y),

+ ) if x == y => (),

+ _ => return false,

+ }

+ }

+ true

+ });

+ match r {

+ Some(x) => {

+ p.local = closure_local;

+ let prev_projs =

+ mem::replace(&mut p.projection, vec![PlaceElem::TupleOrClosureField(x.1)]);

+ if x.0.kind != CaptureKind::ByValue {

+ p.projection.push(ProjectionElem::Deref);

+ }

+ p.projection.extend(prev_projs.into_iter().skip(x.0.place.projections.len()));

+ }

+ None => err = Some(p.clone()),

+ }

+ }

+ });

+ ctx.result.binding_locals = ctx

+ .result

+ .binding_locals

+ .into_iter()

+ .filter(|x| ctx.body[x.0].owner == Some(expr))

+ .collect();

+ if let Some(err) = err {

+ return Err(MirLowerError::UnresolvedUpvar(err));

+ }

+ Ok(Arc::new(ctx.result))

+}

+

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

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

+ let binding_picker = |b: BindingId| {

+ if root_expr == body.body_expr {

+ body[b].owner.is_none()

+ } else {

+ body[b].owner == Some(root_expr)

+ }

+ };

+ let current = if let DefWithBodyId::FunctionId(fid) = owner {

+ ctx.lower_params_and_bindings(

+ body.params.iter().zip(callable_sig.params().iter()).map(|(x, y)| (*x, y.clone())),

+ binding_picker,

+ )?

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

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