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,

inhabitedness::is_ty_uninhabited_from,

layout::LayoutError,

mir::{

AggregateKind, Arena, BasicBlock, BasicBlockId, BinOp, BorrowKind, CastKind, Either, Expr,

FieldId, GenericArgs, Idx, InferenceResult, Local, LocalId, MemoryMap, MirBody, MirSpan,

TupleFieldId, Ty, UnOp, VariantId, return_slot,

},

next_solver::{

infer::{DbInternerInferExt, InferCtxt},

},

traits::FnTrait,

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,

resolver: Resolver<'db>,

infcx: InferCtxt<'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.

fn pop_and_drop<'db>(

self,

ctx: &mut MirLowerCtx<'_, 'db>,

span: MirSpan,

std::mem::forget(self);

ctx.pop_drop_scope_internal(current, span)

}

// }

// }

pub fn pretty_print(

&self,

f: &mut String,

MirLowerError::TypeMismatch(e) => writeln!(

f,

"Type mismatch: Expected {}, found {}",

)?,

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

let param_name = match *id {

param_name.unwrap_or(Name::missing()).display(db, display_target.edition)

)?;

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,

}

}

impl<'a, 'db> MirLowerCtx<'a, 'db> {

fn new(

db: &'db dyn HirDatabase,

owner: DefWithBodyId,

body: &'a Body,

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

// FIXME(next-solver): Is `non_body_analysis()` correct here? Don't we want to reveal opaque types defined by this body?

let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

db,

infer,

body,

owner,

resolver,

current_loop_blocks: None,

self.infcx.interner

}

if matches!(ty.kind(), TyKind::Slice(_) | TyKind::Dynamic(..)) {

}

self.push_storage_live_for_local(l, current, span)?;

Ok(l)

}

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 {

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

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,

konst: Const::new_param(

self.interner(),

ParamConst { id: p, index },

},

span: None,

}),

operands[u32::from(field_id.into_raw()) as usize] = Some(op);

}

let rvalue = Rvalue::Aggregate(

match spread_place {

Some(sp) => operands

.into_iter()

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 {

cast_kind(self.db, source_ty, target_ty)?

};

};

self.push_assignment(current, place, rvalue, expr_id.into());

Ok(Some(current))

self.push_assignment(

current,

place,

expr_id.into(),

);

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

current,

place,

Rvalue::Aggregate(

st.fields(self.db)

.fields()

.iter()

.clone()

.into_iter()

.map(|it| match it {

}

}

})

.collect(),

),

};

match &capture.kind {

CaptureKind::ByRef(bk) => {

// FIXME: Handle more than one span.

let capture_spans = capture.spans();

self.push_assignment(

current,

tmp,

self.push_assignment(

current,

place,

expr_id.into(),

);

Ok(Some(current))

return Ok(None);

};

let r = Rvalue::Aggregate(

values,

);

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

else {

return Ok(None);

};

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

Ok(Some(current))

}

));

}

};

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

Ok(Some(current))

}

}

}

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

if let TyKind::Tuple(..) = self.expr_ty_after_adjustments(*expr).kind() {

let index =

&mut self,

ty: Ty<'db>,

loc: &ExprId,

match &self.body[*loc] {

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

Expr::Path(c) => {

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

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

self.lower_const_to_operand(

c.into(),

)

} else {

}

}

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,

subst: GenericArgs<'db>,

span: MirSpan,

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

&mut self,

subst: GenericArgs<'db>,

const_id: GeneralConstId,

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

Const::new_unevaluated(

self.interner(),

UnevaluatedConst { def: const_id.into(), args: subst },

)

} else {

};

let ty = self

.db

})

.unwrap()

.instantiate(self.interner(), subst);

}

fn write_bytes_to_place(

&mut self,

cv: Box<[u8]>,

ty: Ty<'db>,

span: MirSpan,

fn lower_enum_variant(

&mut self,

variant_id: EnumVariantId,

ty: Ty<'db>,

span: MirSpan,

let subst = match ty.kind() {

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

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

self.push_assignment(

prev_block,

place,

span,

);

Ok(prev_block)

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

}

fn expr_ty_without_adjust(&self, e: ExprId) -> Ty<'db> {

}

fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty<'db> {

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

// FIXME: rustc's ty is dependent on the adt type, maybe we need to do that as well

let discr_ty = Ty::new_int(self.interner(), rustc_type_ir::IntTy::I128);

.temp(discr_ty, current, MirSpan::Unknown)

.expect("discr_ty is never unsized")

.into();

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

self.owner.module(self.db),

)

}

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

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 {

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

self_binding: Option<(BindingId, Ty<'db>)>,

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

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

self.result.binding_locals.insert(self_binding, local_id);

self.result.param_locals.push(local_id);

None => None,

};

self.result.param_locals.extend(params.clone().map(|(it, ty)| {

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

if let Pat::Bind { id, subpat: None } = self.body[it]

&& matches!(

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,

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 Expr::Closure { args, body: root, .. } = &body[expr] else {

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

};

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

};

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

// 0 is return local

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

ty: match kind {

FnTrait::FnMut | FnTrait::AsyncFnMut => Ty::new_ref(

ctx.interner(),

Region::error(ctx.interner()),

Mutability::Mut,

),

FnTrait::Fn | FnTrait::AsyncFn => Ty::new_ref(

ctx.interner(),

Region::error(ctx.interner()),

Mutability::Not,

),

});

ctx.result.param_locals.push(closure_local);

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

for (it, y) in p.projection.lookup(store).iter().zip(it.0.place.projections.iter())

{

match (it, y) {

if it == y => {}

_ => return false,

}

}

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 {

};

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

let body = db.body(def);

result.shrink_to_fit();

Ok(Arc::new(result))

}

pub(crate) fn mir_body_cycle_result<'db>(

_db: &'db dyn HirDatabase,

_def: DefWithBodyId,

Err(MirLowerError::Loop)

}

db: &'db dyn HirDatabase,

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

}

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

// 0 is return local

let binding_picker = |b: BindingId| {

let owner = ctx.body.binding_owner(b);

if root_expr == body.body_expr { owner.is_none() } else { owner == Some(root_expr) }

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

let callable_sig =

db.callable_item_signature(fid.into()).instantiate_identity().skip_binder();

let self_param = body.self_param.and_then(|id| Some((id, params.next()?)));

break 'b ctx.lower_params_and_bindings(

body.params.iter().zip(params).map(|(it, y)| (*it, y)),