mir::{

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

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

},

next_solver::{

Const, DbInterner, ParamConst, ParamEnv, Region, StoredGenericArgs, StoredTy, TyKind,

},

};

mod as_place;

mod pattern_matching;

db: &dyn HirDatabase,

p: &Path,

display_target: DisplayTarget,

store: &ExpressionStore,

) -> Self {

Self::UnresolvedName(

)

}

}

let locals = Arena::new();

let binding_locals: ArenaMap<BindingId, LocalId> = ArenaMap::new();

let mir = MirBody {

basic_blocks,

locals,

start_block,

closures: vec![],

};

let store_owner = owner.expression_store_owner(db);

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

let Some((p, current)) = self.lower_expr_as_place(current, expr_id, true)? else {

return Ok(None);

};

}

fn lower_expr_to_place_with_adjust(

&mut self,

expr_id: ExprId,

current: BasicBlockId,

adjustments: &[Adjustment],

) -> Result<'db, Option<BasicBlockId>> {

self.push_assignment(

current,

place,

expr_id.into(),

);

Ok(Some(current))

place,

Rvalue::Cast(

CastKind::PointerCoercion(*cast),

last.target.clone(),

),

expr_id.into(),

fn lower_expr_to_place_with_borrow_adjust(

&mut self,

expr_id: ExprId,

current: BasicBlockId,

rest: &[Adjustment],

m: Mutability,

return Ok(None);

};

let bk = BorrowKind::from_rustc_mutability(m);

Ok(Some(current))

}

fn lower_expr_to_place(

&mut self,

expr_id: ExprId,

prev_block: BasicBlockId,

) -> Result<'db, Option<BasicBlockId>> {

if let Some(adjustments) = self.infer.expr_adjustments.get(&expr_id) {

fn lower_expr_to_place_without_adjust(

&mut self,

expr_id: ExprId,

mut current: BasicBlockId,

) -> Result<'db, Option<BasicBlockId>> {

match &self.store[expr_id] {

self.db,

p,

DisplayTarget::from_crate(self.db, self.krate()),

self.store,

)

})?;

self.push_assignment(

current,

place,

expr_id.into(),

);

Ok(Some(current))

self.lower_block_to_place(statements, current, *tail, place, expr_id.into())

}

}

self.lower_loop(current, place, *label, expr_id.into(), |this, begin| {

let scope = this.push_drop_scope();

if let Some((_, mut current)) = this.lower_expr_as_place(begin, *body, true)? {

.as_ref()

.ok_or(MirLowerError::BreakWithoutLoop)?,

};

return Ok(None);

};

current = c;

};

let variant_id =

self.infer.variant_resolution_for_expr(expr_id).ok_or_else(|| {

)

})?;

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

.map(|(i, it)| match it {

Some(it) => it,

None => {

parent: variant_id,

local_id: LocalFieldId::from_raw(RawIdx::from(

i as u32,

)),

}

})

.collect(),

};

let local_id =

variant_fields.field(name).ok_or(MirLowerError::UnresolvedField)?;

self.lower_expr_to_place(*expr, place, current)

}

}

return Ok(None);

};

let bk = BorrowKind::from_hir_mutability(*mutability);

Ok(Some(current))

}

Expr::Box { expr } => {

else {

return Ok(None);

};

self.push_assignment(current, p, operand.into(), expr_id.into());

Ok(Some(current))

}

self.push_assignment(

current,

place,

expr_id.into(),

);

Ok(Some(current))

};

let r_value = Rvalue::CheckedBinaryOp(

op.into(),

rhs_op,

);

self.push_assignment(current, lhs_place, r_value, expr_id.into());

};

Ok(Place {

local: this.binding_local(local)?,

})

};

for (place, _, sources) in &closure_data.fake_reads {

let p = convert_place(self, place)?;

}

let captures = closure_data.min_captures.values().flatten();

let tmp_ty = capture.captured_ty(self.db);

// FIXME: Handle more than one span.

let capture_span = span(&capture.info.sources);

self.push_assignment(

current,

tmp,

Rvalue::Ref(BorrowKind::from_hir(bk), p),

capture_span,

);

}

UpvarCapture::ByValue => {

operands.push(Operand { kind: OperandKind::Move(p), span: None })

}

}

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

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

let index =

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

as u32;

} else {

let field =

self.infer.field_resolution(expr_id).ok_or(MirLowerError::UnresolvedField)?;

}

} else {

not_supported!("")

self.db,

c,

DisplayTarget::from_crate(db, owner.krate(db)),

self.store,

)

};

&mut self,

const_id: GeneralConstId,

prev_block: BasicBlockId,

subst: GenericArgs<'db>,

span: MirSpan,

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

fn write_bytes_to_place(

&mut self,

prev_block: BasicBlockId,

cv: Box<[u8]>,

ty: Ty<'db>,

span: MirSpan,

&mut self,

variant_id: EnumVariantId,

prev_block: BasicBlockId,

ty: Ty<'db>,

fields: Box<[Operand]>,

span: MirSpan,

&mut self,

func: Operand,

args: impl Iterator<Item = ExprId>,

mut current: BasicBlockId,

is_uninhabited: bool,

span: MirSpan,

&mut self,

func: Operand,

args: Box<[Operand]>,

current: BasicBlockId,

is_uninhabited: bool,

span: MirSpan,

TerminatorKind::Call {

func,

args,

target: b,

cleanup: None,

from_hir_call: true,

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

}

}

fn push_assignment(

&mut self,

block: BasicBlockId,

rvalue: Rvalue,

span: MirSpan,

) {

}

match &self.discr_temp {

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

tmp

}

}

fn lower_loop(

&mut self,

prev_block: BasicBlockId,

label: Option<LabelId>,

span: MirSpan,

f: impl FnOnce(&mut MirLowerCtx<'_, 'db>, BasicBlockId) -> Result<'db, ()>,

let prev = self.current_loop_blocks.replace(LoopBlocks {

begin,

end: None,

drop_scope_index: self.drop_scopes.len(),

});

let prev_label = if let Some(label) = label {

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

mut current: BasicBlockId,

tail: Option<ExprId>,

span: MirSpan,

) -> Result<'db, Option<Idx<BasicBlock>>> {

let scope = self.push_drop_scope();

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

self.set_terminator(

prev,

span,

);

}

projections.push(ProjectionElem::ClosureField(capture_idx));

let capture_param_place = Place {

local: closure_local,

};

let capture_local_rvalue =

Rvalue::Use(Operand { kind: OperandKind::Move(capture_param_place), span: None });

let local = capture.captured_local();

let local = ctx.binding_local(local)?;

}

let mut err = None;

if let Some(hir_places) = upvar_map.get(&mir_place.local) {

let projections = hir_places.iter().find_map(|hir_place| {

let iter = mir_projections

match projections {

Some((skip_projections_up_to, (hir_place, upvar_local))) => {

mir_place.local = *upvar_local;

}

}

}

});

.to_string(),

InferBodyId::DefWithBodyId(DefWithBodyId::VariantId(it)) => {

let loc = it.lookup(db);

}

InferBodyId::AnonConstId(_) => "{const}".to_owned(),

};