[Closes #471] Add const_assert_generics module

kernel-rs/Cargo.toml

@@ -14,6 +14,7 @@ test = []
 [profile.dev]
 panic = "abort"
 opt-level = 1
+incremental = false
 
 [profile.release]
 panic = "abort"

kernel-rs/src/lib.rs

@@ -45,6 +45,8 @@
 #![feature(const_fn)]
 #![feature(const_fn_fn_ptr_basics)]
 #![feature(const_fn_union)]
+#![feature(const_generics)]
+#![feature(const_evaluatable_checked)]
 #![feature(const_precise_live_drops)]
 #![feature(const_trait_impl)]
 #![feature(generic_associated_types)]

kernel-rs/src/page.rs

@@ -9,6 +9,7 @@ use core::{
 use static_assertions::const_assert;
 
 use crate::arch::addr::{PAddr, PGSIZE};
+use crate::util::const_assert_generics::{Assert2, True};
 
 // `RawPage` must be aligned with PGSIZE.
 const_assert!(PGSIZE == 4096);
@@ -75,16 +76,10 @@ impl Page {
         }
     }
 
-    pub fn as_uninit_mut<T>(&mut self) -> &mut MaybeUninit<T> {
-        // TODO(https://github.com/kaist-cp/rv6/issues/471):
-        // Use const_assert! (or equivalent) instead. Currently, use of T inside const_assert!
-        // incurs a compile error: "can't use generic parameters from outer function".
-        // Also, there's a workaround using feature(const_generics) and
-        // feature(const_evaluatable_checked). However, using them makes the compiler panic.
-        // When the compiler becomes updated, we will fix the following lines to use static checks.
-        assert!(mem::size_of::<T>() <= PGSIZE);
-        assert_eq!(PGSIZE % mem::align_of::<T>(), 0);
-
+    pub fn as_uninit_mut<T>(&mut self) -> &mut MaybeUninit<T>
+    where
+        Assert2<{ mem::size_of::<T>() <= PGSIZE }, { PGSIZE % mem::align_of::<T>() == 0 }>: True,
+    {
         // SAFETY: self.inner is an array of length PGSIZE aligned with PGSIZE bytes.
         // The above assertions show that it can contain a value of T. As it contains arbitrary
         // data, we cannot treat it as &mut T. Instead, we use &mut MaybeUninit<T>. It's ok because

kernel-rs/src/util/const_assert_generics.rs

@@ -0,0 +1,28 @@
+//! Types that let you compile-time assert in `where` clauses,
+//! especially about the input generic parameters.
+//!
+//! # Example
+//! ```rust,no_run
+//! # use core::mem;
+//! #![feature(const_generics)]
+//! #![feature(const_evaluatable_checked)]
+//!
+//! unsafe fn transmute<T, U>(t: T) -> U
+//! where
+//!     Assert2<
+//!         { mem::size_of::<T>() == mem::size_of::<U>() },
+//!         { mem::align_of::<T>() == mem::align_of::<U>() },
+//!     >: True
+//! {
+//!     /* Omitted */
+//! }
+//! ```
+
+pub struct Assert<const EXPR: bool>;
+pub struct Assert2<const EXPR: bool, const EXPR2: bool>;
+pub struct Assert3<const EXPR: bool, const EXPR2: bool, const EXPR3: bool>;
+
+pub trait True {}
+impl True for Assert<true> {}
+impl True for Assert2<true, true> {}
+impl True for Assert3<true, true, true> {}

kernel-rs/src/util/mod.rs

@@ -3,6 +3,7 @@
 // TODO(https://github.com/kaist-cp/rv6/issues/120)
 #![allow(dead_code)]
 
+pub mod const_assert_generics;
 pub mod etrace;
 pub mod list;
 pub mod pinned_array;