use chalk_ir::{BoundVar, ConstData, DebruijnIndex, TyKind};

use hir_def::{

body::Body,

expr::{

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

},

lang_item::{LangItem, LangItemTarget},

layout::LayoutError,

path::Path,

resolver::{resolver_for_expr, ResolveValueResult, ValueNs},

};

use hir_expand::name::Name;

use la_arena::ArenaMap;

use crate::{

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

use super::*;

mod as_place;

struct LoopBlocks {

begin: BasicBlockId,

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

end: Option<BasicBlockId>,

}

struct MirLowerCtx<'a> {

result: MirBody,

owner: DefWithBodyId,

current_loop_blocks: Option<LoopBlocks>,

discr_temp: Option<Place>,

db: &'a dyn HirDatabase,

body: &'a Body,

ConstEvalError(Box<ConstEvalError>),

LayoutError(LayoutError),

IncompleteExpr,

UnresolvedName(String),

RecordLiteralWithoutPath,

UnresolvedMethod,

ImplementationError(&'static str),

LangItemNotFound(LangItem),

MutatingRvalue,

}

macro_rules! not_supported {

mut current: BasicBlockId,

) -> Result<Option<BasicBlockId>> {

match &self.body.exprs[expr_id] {

Expr::Path(p) => {

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

let resolver = resolver_for_expr(self.db.upcast(), self.owner, expr_id);

let pr = resolver

.ok_or_else(unresolved_name)?;

let pr = match pr {

ResolveValueResult::ValueNs(v) => v,

ResolveValueResult::Partial(..) => {

.infer

.assoc_resolutions_for_expr(expr_id)

{

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

return Ok(Some(current))

},

}

} else if let Some(variant) = self

.infer

Ok(Some(current))

}

ValueNs::ConstId(const_id) => {

Ok(Some(current))

}

ValueNs::EnumVariantId(variant_id) => {

Ok(Some(current))

}

ValueNs::GenericParam(p) => {

);

Ok(Some(current))

}

// It's probably a unit struct or a zero sized function, so no action is needed.

Ok(Some(current))

}

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

}

Expr::Unsafe { id: _, statements, tail } => {

}

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

}

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

this.set_goto(block, begin);

}

Ok(())

}),

Expr::While { condition, body, label } => {

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

return Ok(());

};

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

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

current,

pat.into(),

Some(end),

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

this.set_goto(block, begin);

}

})

},

Expr::Call { callee, args, .. } => {

let callee_ty = self.expr_ty_after_adjustments(*callee);

match &callee_ty.data(Interner).kind {

chalk_ir::TyKind::FnDef(..) => {

let func = Operand::from_bytes(vec![], callee_ty.clone());

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

}

}

TyKind::Error => return Err(MirLowerError::MissingFunctionDefinition),

}

}

Expr::MethodCall { receiver, args, .. } => {

let cond_ty = self.expr_ty_after_adjustments(*expr);

let mut end = None;

for MatchArm { pat, guard, expr } in arms.iter() {

current,

None,

cond_place.clone(),

*pat,

BindingAnnotation::Unannotated,

)?;

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

Some(_) => not_supported!("continue with label"),

None => {

let loop_data =

self.set_goto(current, loop_data.begin);

Ok(None)

}

},

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

}

}

Expr::Return { expr } => {

if let Some(expr) = expr {

Ok(None)

}

Expr::Yield { .. } => not_supported!("yield"),

let variant_id = self

.infer

.variant_resolution_for_expr(expr_id)

place,

Rvalue::Aggregate(

AggregateKind::Adt(variant_id, subst),

),

expr_id.into(),

);

}

}

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

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

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

Expr::Const { .. } => not_supported!("anonymous const block"),

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

);

Ok(Some(current))

}

Expr::Closure { .. } => not_supported!("closure"),

Expr::Tuple { exprs, is_assignee_expr: _ } => {

let Some(values) = exprs

const_id: hir_def::ConstId,

prev_block: BasicBlockId,

place: Place,

span: MirSpan,

) -> Result<()> {

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

}

) -> Result<BasicBlockId> {

let subst = match ty.kind(Interner) {

TyKind::Adt(_, subst) => subst.clone(),

};

self.push_assignment(

prev_block,

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

}

fn discr_temp_place(&mut self) -> Place {

match &self.discr_temp {

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

fn lower_loop(

&mut self,

prev_block: BasicBlockId,

label: Option<LabelId>,

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

) -> Result<Option<BasicBlockId>> {

let begin = self.new_basic_block();

self.set_goto(prev_block, begin);

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 lower_block_to_place(

&mut self,

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

mut current: BasicBlockId,

tail: Option<ExprId>,

place: Place,

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

for statement in statements.iter() {

match statement {

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

}

}

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

Ok(match (source_ty.kind(Interner), target_ty.kind(Interner)) {

(TyKind::Scalar(s), TyKind::Scalar(t)) => match (s, t) {

(_, chalk_ir::Scalar::Float(_)) => CastKind::IntToFloat,

(_, _) => CastKind::IntToInt,

},

// Enum to int casts

(TyKind::Scalar(_), TyKind::Adt(..)) | (TyKind::Adt(..), TyKind::Scalar(_)) => {

CastKind::IntToInt

body,

owner,

current_loop_blocks: None,

discr_temp: None,

};

let mut current = start_block;