use std::{fmt::Write, iter, mem};

use base_db::Crate;

use hir_def::{

expr_store::{Body, ExpressionStore, HygieneId, path::Path},

hir::{

ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ExprId, LabelId, Literal, MatchArm,

Pat, PatId, RecordFieldPat, RecordLitField,

},

item_tree::FieldsShape,

resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},

};

use hir_expand::name::Name;

use la_arena::ArenaMap;

use rustc_apfloat::Float;

use rustc_hash::FxHashMap;

use span::{Edition, FileId};

use syntax::TextRange;

use triomphe::Arc;

use crate::{

consteval::ConstEvalError,

db::{HirDatabase, InternedClosure, InternedClosureId},

display::{DisplayTarget, HirDisplay, hir_display_with_store},

generics::generics,

infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy},

inhabitedness::is_ty_uninhabited_from,

layout::LayoutError,

mir::{

},

traits::FnTrait,

};

use super::OperandKind;

mod tests;

#[derive(Debug, Clone)]

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

drop_scope_index: usize,

}

#[derive(Debug, Clone, Default)]

/// locals, in order of definition (so we should run drop glues in reverse order)

}

owner: DefWithBodyId,

db: &'db dyn HirDatabase,

resolver: Resolver<'db>,

}

// FIXME: Make this smaller, its stored in database queries

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

LayoutError(LayoutError),

IncompleteExpr,

IncompletePattern,

RecordLiteralWithoutPath,

UnresolvedMethod(String),

UnresolvedField,

MissingFunctionDefinition(DefWithBodyId, ExprId),

HasErrors,

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

TypeError(&'static str),

Loop,

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

ImplementationError(String),

MutatingRvalue,

UnresolvedLabel,

InaccessibleLocal,

// monomorphization errors:

}

/// A token to ensuring that each drop scope is popped at most once, thanks to the compiler that checks moves.

struct DropScopeToken;

impl DropScopeToken {

self,

span: MirSpan,

std::mem::forget(self);

ctx.pop_drop_scope_internal(current, span)

}

/// code. Either when the control flow is diverging (so drop code doesn't reached) or when drop is handled

/// for us (for example a block that ended with a return statement. Return will drop everything, so the block shouldn't

/// do anything)

std::mem::forget(self);

ctx.pop_drop_scope_assume_dropped_internal();

}

// }

// }

pub fn pretty_print(

&self,

f: &mut String,

e.actual.display(db, display_target),

)?,

MirLowerError::GenericArgNotProvided(id, subst) => {

writeln!(

f,

"Generic arg not provided for {}",

)?;

writeln!(f, "Provided args: [")?;

write!(f, " {},", g.display(db, display_target))?;

}

writeln!(f, "]")?;

| MirLowerError::BreakWithoutLoop

| MirLowerError::Loop

| MirLowerError::ImplementationError(_)

| MirLowerError::MutatingRvalue

| MirLowerError::UnresolvedLabel

| MirLowerError::UnresolvedUpvar(_) => writeln!(f, "{self:?}")?,

}};

}

fn from(value: LayoutError) -> Self {

MirLowerError::LayoutError(value)

}

}

fn unresolved_path(

db: &dyn HirDatabase,

p: &Path,

}

}

fn new(

owner: DefWithBodyId,

) -> Self {

let mut basic_blocks = Arena::new();

let start_block = basic_blocks.alloc(BasicBlock {

is_cleanup: false,

});

let locals = Arena::new();

let mir = MirBody {

projection_store: ProjectionStore::default(),

basic_blocks,

};

let resolver = owner.resolver(db);

let env = db.trait_environment_for_body(owner);

MirLowerCtx {

result: mir,

discr_temp: None,

drop_scopes: vec![DropScope::default()],

env,

}

}

return Err(MirLowerError::UnsizedTemporary(ty));

}

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

fn lower_expr_to_some_operand(

&mut self,

expr_id: ExprId,

if !self.has_adjustments(expr_id)

&& let Expr::Literal(l) = &self.body[expr_id]

{

fn lower_expr_to_place_with_adjust(

&mut self,

expr_id: ExprId,

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(_) => {

);

Ok(Some(current))

}

}

Adjust::Pointer(cast) => {

let Some((p, current)) =

Rvalue::Cast(

CastKind::PointerCoercion(*cast),

Operand { kind: OperandKind::Copy(p), span: None },

),

expr_id.into(),

);

}

}

fn lower_expr_to_place(

&mut self,

expr_id: ExprId,

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

}

fn lower_expr_to_place_without_adjust(

&mut self,

expr_id: ExprId,

match &self.body[expr_id] {

Expr::OffsetOf(_) => {

not_supported!("builtin#offset_of")

let pr =

if let Some((assoc, subst)) = self.infer.assoc_resolutions_for_expr(expr_id) {

match assoc {

return Ok(Some(current));

}

// FnDefs are zero sized, no action is needed.

return Ok(Some(current));

}

}

} else if let Some(variant) = self.infer.variant_resolution_for_expr(expr_id) {

match variant {

const_id.into(),

current,

place,

expr_id.into(),

)?;

Ok(Some(current))

}

ValueNs::EnumVariantId(variant_id) => {

let variant_fields = variant_id.fields(self.db);

if variant_fields.shape == FieldsShape::Unit {

current = self.lower_enum_variant(

variant_id,

current,

not_supported!("owner without generic def id");

};

let generics = generics(self.db, def);

self.push_assignment(

current,

place,

Rvalue::from(Operand {

span: None,

}),

expr_id.into(),

then_target,

place,

Box::new([1]),

MirSpan::Unknown,

)?;

if let Some(else_target) = else_target {

else_target,

place,

Box::new([0]),

MirSpan::Unknown,

)?;

}

}

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

if let Some((func_id, generic_args)) = self.infer.method_resolution(expr_id) {

generic_args,

let func = Operand::from_bytes(Box::default(), ty);

return self.lower_call_and_args(

func,

);

}

let callee_ty = self.expr_ty_after_adjustments(*callee);

self.lower_call_and_args(

func,

args.iter().copied(),

expr_id.into(),

)

}

let Some((func, current)) =

self.lower_expr_to_some_operand(*callee, current)?

else {

"method resolution not emitted for closure (Are Fn traits available?)"

);

}

Err(MirLowerError::MissingFunctionDefinition(self.owner, expr_id))

}

_ => Err(MirLowerError::TypeError("function call on bad type")),

),

None => MirLowerError::RecordLiteralWithoutPath,

})?;

_ => not_supported!("Non ADT record literal"),

};

let variant_fields = variant_id.fields(self.db);

let rvalue = if self.infer.coercion_casts.contains(expr) {

Rvalue::Use(it)

} else {

let cast_kind = if source_ty.as_reference().is_some() {

CastKind::PointerCoercion(PointerCast::ArrayToPointer)

} else {

};

Rvalue::Cast(cast_kind, it, target_ty)

let lhs_ty = self.expr_ty_without_adjust(*lhs);

let rhs_ty = self.expr_ty_without_adjust(*rhs);

if matches!(op, BinaryOp::CmpOp(syntax::ast::CmpOp::Eq { .. }))

{

break 'b true;

}

BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr)

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

);

};

if !is_builtin

&& let Some((func_id, generic_args)) = self.infer.method_resolution(expr_id)

current,

place,

Rvalue::Aggregate(

st.fields(self.db)

.fields()

.iter()

let o = match it.1.name.as_str() {

"start" => lp.take(),

"end" => rp.take(),

_ => None,

};

o.ok_or(MirLowerError::UnresolvedField)

})

),

expr_id.into(),

);

}

Expr::Closure { .. } => {

let ty = self.expr_ty_without_adjust(expr_id);

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

};

let mut operands = vec![];

for capture in captures.iter() {

let p = Place {

};

match &capture.kind {

CaptureKind::ByRef(bk) => {

// FIXME: Handle more than one span.

let capture_spans = capture.spans();

self.push_assignment(

current,

tmp,

current = c;

Ok(Some(o))

})

else {

return Ok(None);

};

}

Expr::Array(l) => match l {

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

_ => {

return Err(MirLowerError::TypeError(

"Array expression with non array type",

current = c;

Ok(Some(o))

})

else {

return Ok(None);

};

else {

return Ok(None);

};

_ => {

return Err(MirLowerError::TypeError(

"Array repeat expression with non array type",

}

}

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

let index =

name.as_tuple_index().ok_or(MirLowerError::TypeError("named field on tuple"))?

as u32;

Ok(())

}

match &self.body[*loc] {

Expr::Literal(l) => self.lower_literal_to_operand(ty, l),

Expr::Path(c) => {

match pr {

ResolveValueResult::ValueNs(v, _) => {

if let ValueNs::ConstId(c) = v {

} else {

not_supported!("bad path in range pattern");

}

}

}

const USIZE_SIZE: usize = size_of::<usize>();

let bytes: Box<[_]> = match l {

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

Ok(Operand::from_concrete_const(bytes, MemoryMap::default(), ty))

}

self.result.basic_blocks.alloc(BasicBlock::default())

}

fn lower_const(

&mut self,

const_id: GeneralConstId,

span: MirSpan,

self.push_assignment(prev_block, place, c.into(), span);

Ok(())

}

fn lower_const_to_operand(

&mut self,

const_id: GeneralConstId,

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

} else {

};

}

fn write_bytes_to_place(

&mut self,

cv: Box<[u8]>,

span: MirSpan,

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

Ok(())

}

fn lower_enum_variant(

&mut self,

variant_id: EnumVariantId,

span: MirSpan,

_ => implementation_error!("Non ADT enum"),

};

self.push_assignment(

fn lower_call_and_args(

&mut self,

args: impl Iterator<Item = ExprId>,

is_uninhabited: bool,

span: MirSpan,

let Some(args) = args

.map(|arg| {

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

Ok(None)

}

})

else {

return Ok(None);

};

fn lower_call(

&mut self,

is_uninhabited: bool,

span: MirSpan,

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

self.set_terminator(

current,

Ok(b)

}

self.result.basic_blocks[source].terminator.is_none()

}

self.result.basic_blocks[source].terminator = Some(Terminator { span, kind: terminator });

}

self.set_terminator(source, TerminatorKind::Goto { target }, span);

}

}

let mut ty = None;

if let Some(it) = self.infer.expr_adjustments.get(&e)

&& let Some(it) = it.last()

{

}

ty.unwrap_or_else(|| self.expr_ty_without_adjust(e))

}

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

}

self.push_statement(block, StatementKind::FakeRead(p).with_span(span));

}

fn push_assignment(

&mut self,

span: MirSpan,

) {

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

}

match &self.discr_temp {

Some(it) => *it,

None => {

.expect("discr_ty is never unsized")

.into();

self.discr_temp = Some(tmp);

fn lower_loop(

&mut self,

label: Option<LabelId>,

span: MirSpan,

let begin = self.new_basic_block();

let prev = self.current_loop_blocks.replace(LoopBlocks {

begin,

fn merge_blocks(

&mut self,

span: MirSpan,

match (b1, b2) {

(None, None) => None,

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

}

}

let r = match self

.current_loop_blocks

.as_mut()

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

is_ty_uninhabited_from(

self.owner.module(self.db),

self.env.clone(),

)

/// This function push `StorageLive` statement for the binding, and applies changes to add `StorageDead` and

/// `Drop` in the appropriated places.

let l = self.binding_local(b)?;

self.push_storage_live_for_local(l, current, MirSpan::BindingId(b))

}

fn push_storage_live_for_local(

&mut self,

span: MirSpan,

self.drop_scopes.last_mut().unwrap().locals.push(l);

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

Ok(())

}

fn lower_block_to_place(

&mut self,

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

tail: Option<ExprId>,

span: MirSpan,

let scope = self.push_drop_scope();

for statement in statements.iter() {

match statement {

fn lower_params_and_bindings(

&mut self,

pick_binding: impl Fn(BindingId) -> bool,

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

let self_binding = match self_binding {

Some((self_binding, ty)) => {

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

self.result

.binding_locals

}

}

let mut current = self.result.start_block;

Ok(current)

}

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

Some(it) => Ok(*it),

None => {

}

}

let r = self.db.const_eval_discriminant(variant);

match r {

Ok(r) => Ok(r),

fn drop_until_scope(

&mut self,

scope_index: usize,

span: MirSpan,

for scope in self.drop_scopes[scope_index..].to_vec().iter().rev() {

self.emit_drop_and_storage_dead_for_scope(scope, &mut current, span);

}

/// Don't call directly

fn pop_drop_scope_internal(

&mut self,

span: MirSpan,

let scope = self.drop_scopes.pop().unwrap();

self.emit_drop_and_storage_dead_for_scope(&scope, &mut current, span);

current

fn pop_drop_scope_assert_finished(

&mut self,

span: MirSpan,

current = self.pop_drop_scope_internal(current, span);

if !self.drop_scopes.is_empty() {

implementation_error!("Mismatched count between drop scope push and pops");

fn emit_drop_and_storage_dead_for_scope(

&mut self,

span: MirSpan,

) {

for &l in scope.locals.iter().rev() {

let prev = std::mem::replace(current, self.new_basic_block());

self.set_terminator(

prev,

}

}

let from = CastTy::from_ty(db, source_ty);

let cast = CastTy::from_ty(db, target_ty);

Ok(match (from, cast) {

})

}

closure: InternedClosureId,

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

let body = db.body(owner);

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

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

};

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

};

// 0 is return local

let closure_local = ctx.result.locals.alloc(Local {

ty: match kind {

},

});

ctx.result.param_locals.push(closure_local);

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

};

let resolver_guard = ctx.resolver.update_to_inner_scope(db, owner, expr);

let current = ctx.lower_params_and_bindings(

None,

|_| true,

)?;

let current = ctx.pop_drop_scope_assert_finished(current, root.into())?;

ctx.set_terminator(current, TerminatorKind::Return, (*root).into());

}

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

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

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

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

}

let krate = def.krate(db);

let edition = krate.data(db).edition;

let detail = match def {

};

let _p = tracing::info_span!("mir_body_query", ?detail).entered();

let body = db.body(def);

result.shrink_to_fit();

Ok(Arc::new(result))

}

_def: DefWithBodyId,

Err(MirLowerError::Loop)

}

owner: DefWithBodyId,

body: &Body,

// FIXME: root_expr should always be the body.body_expr, but since `X` in `[(); X]` doesn't have its own specific body yet, we

// need to take this input explicitly.

root_expr: ExprId,

if infer.type_mismatches().next().is_some() || infer.is_erroneous() {

return Err(MirLowerError::HasErrors);

}

if body.body_expr == root_expr {

// otherwise it's an inline const, and has no parameter

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

let callable_sig =

break 'b ctx.lower_params_and_bindings(

self_param,

binding_picker,

)?;