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

use rustc_ast_ir::Mutability;

use rustc_hash::FxHashMap;

use smallvec::{SmallVec, smallvec};

use stdx::{impl_from, never};

db::{HirDatabase, InternedClosureId},

display::{DisplayTarget, HirDisplay},

infer::PointerCast,

next_solver::{

infer::{InferCtxt, traits::ObligationCause},

obligation_ctxt::ObligationCtxt,

},

use super::consteval::try_const_usize;

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

}

fn from_concrete_const(data: Box<[u8]>, memory_map: MemoryMap<'db>, ty: Ty<'db>) -> Self {

let interner = DbInterner::conjure();

Operand {

kind: OperandKind::Constant {

},

span: None,

}

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

}

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

}

db: &'db dyn HirDatabase,

func_id: hir_def::FunctionId,

generic_args: GenericArgs<'db>,

let ty = Ty::new_fn_def(interner, CallableDefId::FunctionId(func_id).into(), generic_args);

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

}

}

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

Deref,

Field(Either<FieldId, TupleFieldId>),

// FIXME: get rid of this, and use FieldId for tuples and closures

ConstantIndex { offset: u64, from_end: bool },

Subslice { from: u64, to: u64 },

//Downcast(Option<Symbol>, VariantIdx),

}

pub fn projected_ty<'db>(

&self,

infcx: &InferCtxt<'db>,

mut base: Ty<'db>,

closure_field: impl FnOnce(InternedClosureId, GenericArgs<'db>, usize) -> Ty<'db>,

krate: Crate,

if matches!(base.kind(), TyKind::Alias(..)) {

let mut ocx = ObligationCtxt::new(infcx);

match ocx.structurally_normalize_ty(&ObligationCause::dummy(), env, base) {

Ok(it) => base = it,

Err(_) => return Ty::new_error(interner, ErrorGuaranteed),

match self {

ProjectionElem::Deref => match base.kind() {

TyKind::RawPtr(inner, _) | TyKind::Ref(_, inner, _) => inner,

_ => {

never!(

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

},

ProjectionElem::Field(Either::Left(f)) => match base.kind() {

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

}

ty => {

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

}

}

#[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.

},

}

}

}

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

///

/// The validity requirements for the underlying value are undecided for this rvalue, see

/// [#91095]. Note too that the value of the discriminant is not the same thing as the

///

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

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

pub closures: Vec<InternedClosureId>,

}

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

}

) {

match &mut op.kind {

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