use la_arena::ArenaMap;

use rustc_apfloat::Float;

use rustc_hash::FxHashMap;

use span::{Edition, FileId};

use syntax::TextRange;

use triomphe::Arc;

locals: Vec<LocalId>,

}

result: MirBody,

owner: DefWithBodyId,

current_loop_blocks: Option<LoopBlocks>,

labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>,

discr_temp: Option<Place>,

db: &'db dyn HirDatabase,

resolver: Resolver<'db>,

drop_scopes: Vec<DropScope>,

env: Arc<TraitEnvironment<'db>>,

}

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

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

LayoutError(LayoutError),

IncompleteExpr,

IncompletePattern,

UnresolvedField,

UnsizedTemporary(Ty),

MissingFunctionDefinition(DefWithBodyId, ExprId),

HasErrors,

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

TypeError(&'static str),

impl DropScopeToken {

fn pop_and_drop(

self,

current: BasicBlockId,

span: MirSpan,

) -> BasicBlockId {

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

}};

}

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 {

};

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,

}

}

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

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

}

&mut self,

expr_id: ExprId,

current: BasicBlockId,

if !self.has_adjustments(expr_id)

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

{

expr_id: ExprId,

place: Place,

current: BasicBlockId,

match adjustments.split_last() {

Some((last, rest)) => match &last.kind {

Adjust::NeverToAny => {

else {

return Ok(None);

};

self.push_assignment(current, place, Rvalue::Ref(bk, p), expr_id.into());

Ok(Some(current))

}

Rvalue::Cast(

CastKind::PointerCoercion(*cast),

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

),

expr_id.into(),

);

expr_id: ExprId,

place: Place,

prev_block: BasicBlockId,

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

}

expr_id: ExprId,

place: Place,

mut current: BasicBlockId,

match &self.body[expr_id] {

Expr::OffsetOf(_) => {

not_supported!("builtin#offset_of")

c.into(),

current,

place,

expr_id.into(),

self.expr_ty_without_adjust(expr_id),

)?;

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,

place,

Box::new([]),

expr_id.into(),

)?;

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

let ty = chalk_ir::TyKind::FnDef(

CallableDefId::FunctionId(func_id).to_chalk(self.db),

)

.intern(Interner);

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

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

)

})?;

self.lower_call_and_args(

func,

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

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 {

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

};

o.ok_or(MirLowerError::UnresolvedField)

})

),

expr_id.into(),

);

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

};

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

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

let tmp: Place = self.temp(tmp_ty, current, capture_spans[0])?.into();

current = c;

Ok(Some(o))

})

else {

return Ok(None);

};

current = c;

Ok(Some(o))

})

else {

return Ok(None);

};

}

}

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

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

let index =

Ok(())

}

match &self.body[*loc] {

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

Expr::Path(c) => {

}

}

let interner = DbInterner::new_with(self.db, None, None);

let size = || {

self.db

subst: Substitution,

span: MirSpan,

ty: Ty,

let c = self.lower_const_to_operand(subst, const_id, ty)?;

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

Ok(())

subst: Substitution,

const_id: GeneralConstId,

ty: Ty,

let c = if subst.len(Interner) != 0 {

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

intern_const_scalar(ConstScalar::UnevaluatedConst(const_id, subst), ty)

cv: Box<[u8]>,

ty: Ty,

span: MirSpan,

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

Ok(())

}

ty: Ty,

fields: Box<[Operand]>,

span: MirSpan,

let subst = match ty.kind(Interner) {

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

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

mut current: BasicBlockId,

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

};

current: BasicBlockId,

is_uninhabited: bool,

span: MirSpan,

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

self.set_terminator(

current,

}

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

}

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

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

}

place: Place,

label: Option<LabelId>,

span: MirSpan,

let begin = self.new_basic_block();

let prev = self.current_loop_blocks.replace(LoopBlocks {

begin,

}

}

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

}

l: LocalId,

current: BasicBlockId,

span: MirSpan,

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

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

Ok(())

}

let crate_id = self.owner.module(self.db).krate();

lang_item(self.db, crate_id, item).ok_or(MirLowerError::LangItemNotFound(item))

}

tail: Option<ExprId>,

place: Place,

span: MirSpan,

let scope = self.push_drop_scope();

for statement in statements.iter() {

match statement {

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

self_binding: Option<(BindingId, Ty)>,

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

}

}

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

match r {

Ok(r) => Ok(r),

&mut self,

mut current: BasicBlockId,

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

}

}

Ok(match (from, cast) {

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

CastKind::PointerExposeAddress

})

}

closure: InternedClosureId,

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

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

};

implementation_error!("closure expression is not 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 {

FnTrait::FnMut | FnTrait::AsyncFnMut => {

}

FnTrait::Fn | FnTrait::AsyncFn => {

}

},

});

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 {

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

}