use base_db::Crate;

use hir_def::{

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

hir::{

ArithOp, Array, BinaryOp, BindingAnnotation, BindingId, ClosureKind, ExprId, ExprOrPatId,

use la_arena::ArenaMap;

use rustc_apfloat::Float;

use rustc_hash::FxHashMap;

use span::{Edition, FileId};

use syntax::TextRange;

use crate::{

consteval::ConstEvalError,

display::{DisplayTarget, HirDisplay, hir_display_with_store},

generics::generics,

infer::{

cast::CastTy,

closure::analysis::expr_use_visitor::{

Place as HirPlace, PlaceBase as HirPlaceBase, ProjectionKind as HirProjectionKind,

struct MirLowerCtx<'a, 'db> {

result: MirBody,

current_loop_blocks: Option<LoopBlocks>,

labeled_loop_blocks: FxHashMap<LabelId, LoopBlocks>,

discr_temp: Option<Place>,

UnresolvedMethod(String),

UnresolvedField,

UnsizedTemporary(StoredTy),

HasErrors,

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

TypeError(&'static str),

}

}

MirLowerError::MissingFunctionDefinition(owner, it) => {

writeln!(

f,

"Missing function definition for {}",

)?;

}

MirLowerError::HasErrors => writeln!(f, "Type inference result contains errors")?,

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

let param_name = match *id {

GenericParamId::TypeParamId(id) => {

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

fn new(

db: &'db dyn HirDatabase,

store: &'a ExpressionStore,

infer: &'a InferenceResult,

) -> Self {

owner,

closures: vec![],

};

let interner = DbInterner::new_with(db, resolver.krate());

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

store,

types: crate::next_solver::default_types(db),

owner,

resolver,

current_loop_blocks: None,

labeled_loop_blocks: Default::default(),

not_supported!("builtin#asm")

}

Expr::Missing => {

let assoc = f.lookup(self.db);

if let ItemContainerId::TraitId(t) = assoc.container {

let name = &FunctionSignature::of(self.db, f).name;

}

} else {

let resolver_guard =

let hygiene = self.store.expr_path_hygiene(expr_id);

let result = self

.resolver

Ok(Some(current))

}

ValueNs::GenericParam(p) => {

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

self.push_assignment(

current,

place,

ParamConst { id: p, index },

)

.store(),

},

span: None,

}),

};

self.push_fake_read(current, cond_place, expr_id.into());

let resolver_guard =

let (then_target, else_target) =

self.pattern_match(current, None, cond_place, *pat)?;

self.resolver.reset_to_guard(resolver_guard);

self.push_fake_read(current, cond_place, expr_id.into());

let mut end = None;

let resolver_guard =

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

let (then, mut otherwise) =

self.pattern_match(current, None, cond_place, *pat)?;

RecordSpread::FieldDefaults => not_supported!("empty record spread"),

};

let variant_id =

.display(self.db, self.display_target())

.to_string(),

})?;

let subst = match self.expr_ty_without_adjust(expr_id).kind() {

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

};

self.push_fake_read(current, value, expr_id.into());

let resolver_guard =

current = self.pattern_match_assignment(current, value, target)?;

self.resolver.reset_to_guard(resolver_guard);

Ok(Some(current))

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

};

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

let span = |sources: &[CaptureSourceStack]| match sources

.first()

subst: GenericArgs<'db>,

const_id: GeneralConstId,

) -> Result<'db, Operand> {

let konst = Const::new_unevaluated(

self.interner(),

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

);

Ok(Operand {

kind: OperandKind::Constant { konst: konst.store(), ty: ty.store() },

span: None,

self.push_fake_read(current, init_place, span);

// Using the initializer for the resolver scope is good enough for us, as it cannot create new declarations

// and has all declarations of the `let`.

(current, else_block) =

self.pattern_match(current, None, init_place, *pat)?;

self.resolver.reset_to_guard(resolver_guard);

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

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

None => {

// never!("Using inaccessible local for binding is always a bug");

Err(MirLowerError::InaccessibleLocal)

}

}

TyKind::Adt(adt_def, _) => {

let local_field_id = LocalFieldId::from_raw(RawIdx::from_u32(field_idx));

AdtId::StructId(id) => {

FieldId { parent: id.into(), local_id: local_field_id }

}

})

}

pub fn mir_body_for_closure_query<'db>(

db: &'db dyn HirDatabase,

closure: InternedClosureId,

let infer = InferenceResult::of(db, body_owner);

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

};

let crate::next_solver::TyKind::Closure(_, substs) = infer.expr_ty(expr).kind() else {

};

let kind = substs.as_closure().kind();

let captures = infer.closures_data[&expr].min_captures.values().flatten();

// 0 is return local

ctx.result.locals.alloc(Local { ty: infer.expr_ty(*root).store() });

ctx.result.param_locals.push(closure_local);

let sig = ctx.interner().signature_unclosure(substs.as_closure().sig(), Safety::Safe);

let current = ctx.lower_params_and_bindings(

args.iter().zip(sig.skip_binder().inputs().iter()).map(|(it, y)| (*it, *y)),

None,

return Err(MirLowerError::UnresolvedUpvar(err));

}

ctx.result.shrink_to_fit();

}

let krate = def.krate(db);

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

let detail = match def {

FunctionSignature::of(db, it).name.display(db, edition).to_string()

}

StaticSignature::of(db, it).name.display(db, edition).to_string()

}

.name

.clone()

.unwrap_or_else(Name::missing)

.display(db, edition)

.to_string(),

let loc = it.lookup(db);

loc.parent.enum_variants(db).variants[loc.index as usize]

.1

.display(db, edition)

.to_string()

}

};

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

let infer = InferenceResult::of(db, def);

result.shrink_to_fit();

}

_db: &'db dyn HirDatabase,

_: salsa::Id,

Err(MirLowerError::Loop)

}

/// then delegates to [`lower_to_mir_with_store`].

pub fn lower_body_to_mir<'db>(

db: &'db dyn HirDatabase,

infer: &InferenceResult,

root_expr: ExprId,

) -> Result<'db, MirBody> {

// Extract params and self_param only when lowering the body's root expression for a function.

let callable_sig =

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

let mut param_tys = callable_sig.inputs().iter().copied();

lower_to_mir_with_store(

db,

owner,

infer,

root_expr,

self_param,

)

} else {

}

}

/// const (picks bindings owned by `root_expr`).

pub fn lower_to_mir_with_store<'db>(

db: &'db dyn HirDatabase,

store: &ExpressionStore,

infer: &InferenceResult,

root_expr: ExprId,

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

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

) -> Result<'db, MirBody> {

return Err(MirLowerError::HasErrors);

}

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

// 0 is return local

ctx.result.locals.alloc(Local { ty: ctx.expr_ty_after_adjustments(root_expr).store() });

let current = ctx.lower_params_and_bindings(params, self_param, binding_picker)?;

if let Some(current) = ctx.lower_expr_to_place(root_expr, return_slot().into(), current)? {

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