//! Monomorphization of mir, which is used in mir interpreter and const eval.
//!
//! The job of monomorphization is:
//! * Monomorphization. That is, replacing `Option<T>` with `Option<i32>` where `T:=i32` substitution
//!   is provided
//! * Normalizing types, for example replacing RPIT of other functions called in this body.
//!
//! So the monomorphization should be called even if the substitution is empty.

use std::mem;

use base_db::ra_salsa::Cycle;
use chalk_ir::{
    fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable},
    ConstData, DebruijnIndex,
};
use hir_def::DefWithBodyId;
use triomphe::Arc;

use crate::{
    consteval::{intern_const_scalar, unknown_const},
    db::{HirDatabase, InternedClosure},
    from_placeholder_idx,
    generics::{generics, Generics},
    infer::normalize,
    ClosureId, Const, Interner, ProjectionTy, Substitution, TraitEnvironment, Ty, TyKind,
};

use super::{MirBody, MirLowerError, Operand, Rvalue, StatementKind, TerminatorKind};

macro_rules! not_supported {
    ($it: expr) => {
        return Err(MirLowerError::NotSupported(format!($it)))
    };
}

struct Filler<'a> {
    db: &'a dyn HirDatabase,
    trait_env: Arc<TraitEnvironment>,
    subst: &'a Substitution,
    generics: Option<Generics>,
    owner: DefWithBodyId,
}
impl FallibleTypeFolder<Interner> for Filler<'_> {
    type Error = MirLowerError;

    fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<Interner, Error = Self::Error> {
        self
    }

    fn interner(&self) -> Interner {
        Interner
    }

    fn try_fold_ty(
        &mut self,
        ty: Ty,
        outer_binde