use std::{collections::hash_map::Entry, fmt::Display, iter};

use base_db::Crate;

use either::Either;

use hir_def::{

DefWithBodyId, FieldId, StaticId, TupleFieldId, UnionId, VariantId,

hir::{BindingAnnotation, BindingId, Expr, ExprId, Ordering, PatId},

};

use la_arena::{Arena, ArenaMap, Idx, RawIdx};

mod borrowck;

mod eval;

};

pub use lower::{MirLowerError, lower_to_mir, mir_body_for_closure_query, mir_body_query};

pub use monomorphization::{

};

pub(crate) use lower::mir_body_cycle_result;

pub(crate) use monomorphization::monomorphized_mir_body_cycle_result;

LocalId::from_raw(RawIdx::from(0))

}

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

}

/// An operand in MIR represents a "value" in Rust, the definition of which is undecided and part of

/// currently implements it, but it seems like this may be something to check against in the

/// validator.

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

// FIXME : This should actually just be of type `MirSpan`.

span: Option<MirSpan>,

}

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

/// Creates a value by loading the given place.

///

/// Before drop elaboration, the type of the place must be `Copy`. After drop elaboration there

/// is no such requirement.

/// Creates a value by performing loading the place, just like the `Copy` operand.

///

/// place without first re-initializing it.

///

/// [UCG#188]: https://github.com/rust-lang/unsafe-code-guidelines/issues/188

/// Constants are already semantically values, and remain unchanged.

/// NON STANDARD: This kind of operand returns an immutable reference to that static memory. Rustc

/// handles it with the `Constant` variant somehow.

Static(StaticId),

}

Operand {

ty,

span: None,

}

}

Operand::from_concrete_const(data, MemoryMap::default(), ty)

}

Self::from_bytes(Box::default(), ty)

}

fn from_fn(

func_id: hir_def::FunctionId,

Operand::from_bytes(Box::default(), ty)

}

}

}

impl<V, T> ProjectionElem<V, T> {

&self,

krate: Crate,

// we only bail on mir building when there are type mismatches

// but error types may pop up resulting in us still attempting to build the mir

// so just propagate the error type

}

}

match self {

_ => {

never!(

"Overloaded deref on type {} is not a projection",

base.display(db, DisplayTarget::from_crate(db, krate))

);

}

},

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

}

ty => {

never!("Only adt has field, found {:?}", ty);

}

},

never!("Out of bound tuple field");

ty => {

never!("Only tuple has tuple field: {:?}", ty);

}

},

_ => {

never!("Only closure has closure field");

}

},

}

TyKind::Array(inner, c) => {

let next_c = usize_const(

db,

},

krate,

);

}

_ => {

never!("Subslice projection should only happen on slice and array");

}

},

ProjectionElem::OpaqueCast(_) => {

never!("We don't emit these yet");

}

}

}

}

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

pub struct ProjectionId(u32);

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

}

fn default() -> Self {

let mut this = Self { id_to_proj: Default::default(), proj_to_id: Default::default() };

// Ensure that [] will get the id 0 which is used in `ProjectionId::Empty`

}

}

pub fn shrink_to_fit(&mut self) {

self.id_to_proj.shrink_to_fit();

self.proj_to_id.shrink_to_fit();

}

self.proj_to_id.get(projection).copied()

}

let new_id = ProjectionId(self.proj_to_id.len() as u32);

match self.proj_to_id.entry(projection) {

Entry::Occupied(id) => *id.get(),

self == ProjectionId::EMPTY

}

store.id_to_proj.get(&self).unwrap()

}

let mut current = self.lookup(store).to_vec();

current.push(projection);

store.intern(current.into())

}

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

pub projection: ProjectionId,

}

self.local == child.local

&& child.projection.lookup(store).starts_with(self.projection.lookup(store))

}

/// The place itself is not included

fn iterate_over_parents<'a>(

&'a self,

let projection = self.projection.lookup(store);

(0..projection.len()).map(|x| &projection[0..x]).filter_map(move |x| {

Some(Place { local: self.local, projection: store.intern_if_exist(x)? })

})

}

Place { local: self.local, projection: self.projection.project(projection, store) }

}

}

Self { local, projection: ProjectionId::EMPTY }

}

}

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

/// The type is of the element

/// The type is of the tuple

Union(UnionId, FieldId),

//Coroutine(LocalDefId, SubstsRef, Movability),

}

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

/// Possible values. The locations to branch to in each case

/// are found in the corresponding indices from the `targets` vector.

values: SmallVec<[u128; 1]>,

//

// However we’ve decided to keep this as-is until we figure a case

// where some other approach seems to be strictly better than other.

}

/// Creates switch targets from an iterator of values and target blocks.

///

/// The iterator may be empty, in which case the `SwitchInt` instruction is equivalent to

/// `goto otherwise;`.

pub fn new(

) -> Self {

let (values, mut targets): (SmallVec<_>, SmallVec<_>) = targets.unzip();

targets.push(otherwise);

/// Builds a switch targets definition that jumps to `then` if the tested value equals `value`,

/// and to `else_` if not.

Self { values: smallvec![value], targets: smallvec![then, else_] }

}

/// Returns the fallback target that is jumped to when none of the values match the operand.

*self.targets.last().unwrap()

}

/// including the `otherwise` fallback target.

///

/// Note that this may yield 0 elements. Only the `otherwise` branch is mandatory.

iter::zip(&self.values, &self.targets).map(|(x, y)| (*x, *y))

}

/// Returns a slice with all possible jump targets (including the fallback target).

&self.targets

}

/// Finds the `BasicBlock` to which this `SwitchInt` will branch given the

/// specific value. This cannot fail, as it'll return the `otherwise`

/// branch if there's not a specific match for the value.

self.iter().find_map(|(v, t)| (v == value).then_some(t)).unwrap_or_else(|| self.otherwise())

}

}

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

pub span: MirSpan,

}

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

/// Block has one successor; we continue execution there.

/// Switches based on the computed value.

///

/// Target values may not appear more than once.

SwitchInt {

/// The discriminant value being tested.

},

/// Indicates that the landing pad is finished and that the process should continue unwinding.

/// > The drop glue is executed if, among all statements executed within this `Body`, an assignment to

/// > the place or one of its "parents" occurred more recently than a move out of it. This does not

/// > consider indirect assignments.

/// Drops the place and assigns a new value to it.

///

///

/// Disallowed after drop elaboration.

DropAndReplace {

},

/// Roughly speaking, evaluates the `func` operand and the arguments, and starts execution of

/// [#71117]: https://github.com/rust-lang/rust/issues/71117

Call {

/// The function that’s being called.

/// Arguments the function is called with.

/// These are owned by the callee, which is free to modify them.

/// This allows the memory occupied by "by-value" arguments to be

/// reused across function calls without duplicating the contents.

/// Where the returned value will be written

/// Where to go after this call returns. If none, the call necessarily diverges.

/// Cleanups to be done if the call unwinds.

/// `true` if this is from a call in HIR rather than from an overloaded

/// operator. True for overloaded function call.

from_hir_call: bool,

/// necessarily executed even in the case of a panic, for example in `-C panic=abort`. If the

/// assertion does not fail, execution continues at the specified basic block.

Assert {

expected: bool,

//msg: AssertMessage,

},

/// Marks a suspend point.

/// **Needs clarification**: What about the evaluation order of the `resume_arg` and `value`?

Yield {

/// The value to return.

/// Where to resume to.

/// The place to store the resume argument in.

/// Cleanup to be done if the coroutine is dropped at this suspend point.

},

/// Indicates the end of dropping a coroutine.

/// Disallowed after drop elaboration.

FalseEdge {

/// The target normal control flow will take.

/// A block control flow could conceptually jump to, but won't in

/// practice.

},

/// A terminator for blocks that only take one path in reality, but where we reserve the right

/// Disallowed after drop elaboration.

FalseUnwind {

/// The target normal control flow will take.

/// The imaginary cleanup block link. This particular path will never be taken

/// in practice, but in order to avoid fragility we want to always

/// consider it in borrowck. We don't want to accept programs which

/// pass borrowck only when `panic=abort` or some assertions are disabled

/// due to release vs. debug mode builds. This needs to be an `Option` because

/// of the `remove_noop_landing_pads` and `abort_unwinding_calls` passes.

},

}

}

}

match m {

}

}

}

}

}

Self::Use(x)

}

}

}

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

/// Yields the operand unchanged

/// Creates an array where each element is the value of the operand.

///

/// Corresponds to source code like `[x; 32]`.

/// Creates a reference of the indicated kind to the place.

///

/// exactly what the behavior of this operation should be.

///

/// `Shallow` borrows are disallowed after drop lowering.

/// Creates a pointer/reference to the given thread local.

///

/// If the type of the place is an array, this is the array length. For slices (`[T]`, not

/// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is

/// ill-formed for places of other types.

/// Performs essentially all of the casts that can be performed via `as`.

///

///

/// **FIXME**: Document exactly which `CastKind`s allow which types of casts. Figure out why

/// `ArrayToPointer` and `MutToConstPointer` are special.

// FIXME link to `pointer::offset` when it hits stable.

/// * `Offset` has the same semantics as `pointer::offset`, except that the second

/// when the value of right-hand side is negative.

///

/// Other combinations of types and operators are unsupported.

/// Computes a value as described by the operation.

//NullaryOp(NullOp, Ty),

/// Also does two's-complement arithmetic. Negation requires a signed integer or a float;

/// bitwise not requires a signed integer, unsigned integer, or bool. Both operation kinds

/// return a value with the same type as their operand.

/// Computes the discriminant of the place, returning it as an integer of type

/// [`discriminant_ty`]. Returns zero for types without discriminant.

/// [`discriminant_ty`]: crate::ty::Ty::discriminant_ty

/// [#91095]: https://github.com/rust-lang/rust/issues/91095

/// [`discriminant_for_variant`]: crate::ty::Ty::discriminant_for_variant

/// Creates an aggregate value, like a tuple or struct.

///

///

/// Disallowed after deaggregation for all aggregate kinds except `Array` and `Coroutine`. After

/// coroutine lowering, `Coroutine` aggregate kinds are disallowed too.

/// Transmutes a `*mut u8` into shallow-initialized `Box<T>`.

///

/// This is different from a normal transmute because dataflow analysis will treat the box as

/// initialized but its content as uninitialized. Like other pointer casts, this in general

/// affects alias analysis.

/// NON STANDARD: allocates memory with the type's layout, and shallow init the box with the resulting pointer.

/// A CopyForDeref is equivalent to a read from a place at the

/// codegen level, but is treated specially by drop elaboration. When such a read happens, it

/// read never happened and just projects further. This allows simplifying various MIR

/// optimizations and codegen backends that previously had to handle deref operations anywhere

/// in a place.

}

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

//SetDiscriminant {

// place: Box<Place>,

// variant_index: VariantIdx,

//},

//Retag(RetagKind, Box<Place>),

//AscribeUserType(Place, UserTypeProjection, Variance),

//Intrinsic(Box<NonDivergingIntrinsic>),

Nop,

}

Statement { kind: self, span }

}

}

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

pub span: MirSpan,

}

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

/// List of statements in this block.

/// Terminator for this block.

///

/// exception is that certain passes, such as `simplify_cfg`, swap

/// out the terminator temporarily with `None` while they continue

/// to recurse over the set of basic blocks.

/// If true, this block lies on an unwind path. This is used

/// during codegen where distinct kinds of basic blocks may be

}

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

pub owner: DefWithBodyId,

/// This field stores the closures directly owned by this body. It is used

/// in traversing every mir body.

}

self.binding_locals.iter().map(|(it, y)| (*y, it)).collect()

}

) {

match &mut op.kind {

OperandKind::Copy(p) | OperandKind::Move(p) => {

f(p, store);

}

}

}

for (_, block) in self.basic_blocks.iter_mut() {