//! 受 `rustc_arena::DroplessArena` 启发的最小竞技场分配器。
//!
//! 不幸的是，这是一个最小的重新实现而不是依赖，因为在 `proc_macro` 中很难依赖 crates，因为它是与 `std` 同时构建的。
//!
//!

use std::cell::{Cell, RefCell};
use std::cmp;
use std::mem::MaybeUninit;
use std::ops::Range;
use std::ptr;
use std::slice;
use std::str;

// arenas 以 PAGE 大小的块开始，然后每个新块的大小是其前一个块的两倍，直到我们达到 HUGE_PAGE 大小的块，然后我们停止增长。
// 这可以很好地扩展，从几乎不使用的竞技场到用于 100 多个 MiB 的竞技场。
// 另请注意，所选大小与 Linux 上页面和大页面的通常大小相匹配。
//
//
const PAGE: usize = 4096;
const HUGE_PAGE: usize = 2 * 1024 * 1024;

/// 受 `rustc_arena::DroplessArena` 启发的最小竞技场分配器。
///
/// 不幸的是，这是一个完整的重新实现而不是依赖，因为在 `proc_macro` 中很难依赖 crates，因为它是与 `std` 同时构建的。
///
///
/// 这个 arena 不支持分配字节片以外的任何东西，因为这就是所有必要的。
///
///
pub(crate) struct Arena {
    start: Cell<*mut MaybeUninit<u8>>,
    end: Cell<*mut MaybeUninit<u8>>,
    chunks: RefCell<Vec<Box<[MaybeUninit<u8>]>>>,
}

impl Arena {
    pub(crate) fn new() -> Self {
        Arena {
            start: Cell::new(ptr::null_mut()),
            end: Cell::new(ptr::null_mut()),
            chunks: RefCell::new(Vec::new()),
        }
    }

    /// 添加一个至少有 `additional` 个空闲字节的新块。
    #[inline(never)]
    #[cold]
    fn grow(&self, additional: usize) {
        let mut chunks = self.chunks.borrow_mut();
        let mut new_cap;
        if let Some(last_chunk) = chunks.last_mut() {
            // 如果前一个块的长度小于 HUGE_PAGE 字节，那么这个块将至少是前一个块大小的两倍。
            //
            //
            new_cap = last_chunk.len().min(HUGE_PAGE / 2);
            new_cap *= 2;
        } else {
            new_cap = PAGE;
        }
        // 还要确保这个块可以适合 `additional`。
        new_cap = cmp::max(additional, new_cap);

        let mut chunk = Box::new_uninit_slice(new_cap);
        let Range { start, end } = chunk.as_mut_ptr_range();
        self.start.set(start);
        self.end.set(end);
        chunks.push(chunk);
    }

    /// 从当前内存块中分配一个指定大小的字节片。
    /// 如果没有剩余空间来满足请求，则返回 `None`。
    ///
    fn alloc_raw_without_grow(&self, bytes: usize) -> Option<&mut [MaybeUninit<u8>]> {
        let start = self.start.get().addr();
        let old_end = self.end.get();
        let end = old_end.addr();

        let new_end = end.checked_sub(bytes)?;
        if start <= new_end {
            let new_end = old_end.with_addr(new_end);
            self.end.set(new_end);
            // SAFETY: 从 `new_end` 开始的 `bytes` 字节刚刚被保留。
            Some(unsafe { slice::from_raw_parts_mut(new_end, bytes) })
        } else {
            None
        }
    }

    fn alloc_raw(&self, bytes: usize) -> &mut [MaybeUninit<u8>] {
        if bytes == 0 {
            return &mut [];
        }

        loop {
            if let Some(a) = self.alloc_raw_without_grow(bytes) {
                break a;
            }
            // 没有剩余空间。分配一个新的块来满足请求。
            // 失败时，增长将 panic 或中止。
            self.grow(bytes);
        }
    }

    pub(crate) fn alloc_str<'a>(&'a self, string: &str) -> &'a mut str {
        let alloc = self.alloc_raw(string.len());
        let bytes = MaybeUninit::write_slice(alloc, string.as_bytes());

        // SAFETY: 我们从 `&str` 转换为 `&[u8]`，将其克隆到竞技场中，然后立即将克隆转换回 `&str`。
        //
        unsafe { str::from_utf8_unchecked_mut(bytes) }
    }
}