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,

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::{

},

next_solver::{

},

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)

}

struct MirLowerCtx<'a, 'db> {

owner: DefWithBodyId,

db: &'db dyn HirDatabase,

body: &'a Body,

infer: &'a InferenceResult<'db>,

resolver: Resolver<'db>,

env: Arc<TraitEnvironment<'db>>,

}

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

RecordLiteralWithoutPath,

UnresolvedMethod(String),

UnresolvedField,

MissingFunctionDefinition(DefWithBodyId, ExprId),

TypeMismatch(TypeMismatch<'db>),

HasErrors,

LangItemNotFound(LangItem),

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)

}

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, "]")?;

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

let interner = DbInterner::new_with(db, Some(env.krate), env.block);

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,

adjustments: &[Adjustment<'db>],

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

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

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

match assoc {

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

return Ok(Some(current));

}

hir_def::AssocItemId::FunctionId(_) => {

const_id.into(),

current,

place,

expr_id.into(),

)?;

Ok(Some(current))

}

variant_id,

current,

place,

Box::new([]),

expr_id.into(),

)?;

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

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")),

method_name.display(self.db, self.edition()).to_string(),

)

})?;

self.lower_call_and_args(

func,

iter::once(*receiver).chain(args.iter().copied()),

),

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)

{

return self.lower_call_and_args(

func,

[*lhs, *rhs].into_iter(),

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::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 {

ProjectionElem::Subslice { from, to }

}

ProjectionElem::OpaqueCast(it) => {

}

#[allow(unreachable_patterns)]

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

};

match &capture.kind {

CaptureKind::ByRef(bk) => {

// FIXME: Handle more than one span.

let capture_spans = capture.spans();

self.push_assignment(

current,

tmp,

}

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

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

_ => {

return Err(MirLowerError::TypeError(

"Array expression with non array type",

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,

) -> Result<'db, ()> {

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 {

let name = const_id.name(self.db);

self.db

.const_eval(const_id, subst, None)

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

};

}

fn write_bytes_to_place(

&mut self,

cv: Box<[u8]>,

span: MirSpan,

) -> Result<'db, ()> {

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

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

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.db,

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,

) -> Result<'db, ()> {

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

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

continue;

}

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

}

}

let mut current = self.result.start_block;

Ok(current)

}

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

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

None => {

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,

fn cast_kind<'db>(

db: &'db dyn HirDatabase,

) -> Result<'db, CastKind> {

Ok(match (from, cast) {

(Some(CastTy::Ptr(..) | CastTy::FnPtr), Some(CastTy::Int(_))) => {

CastKind::PointerExposeAddress

pub fn mir_body_for_closure_query<'db>(

db: &'db dyn HirDatabase,

closure: InternedClosureId,

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

let body = db.body(owner);

let infer = db.infer(owner);

};

let (captures, kind) = infer.closure_info(closure);

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

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

pub fn mir_body_query<'db>(

db: &'db dyn HirDatabase,

def: DefWithBodyId,

let krate = def.krate(db);

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

let detail = match def {

pub(crate) fn mir_body_cycle_result<'db>(

_db: &'db dyn HirDatabase,

_def: DefWithBodyId,

Err(MirLowerError::Loop)

}

// 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 {

break 'b ctx.lower_params_and_bindings(

self_param,

binding_picker,

)?;