Use rustversion to conditionally make methods const

Signed-off-by: Joe Richey <[email protected]>

Author: josephlr

Cargo.toml

@@ -29,6 +29,7 @@ edition = "2018"
 bit_field = "0.10.1"
 bitflags = "1.0.4"
 volatile = "0.4.4"
+rustversion = "1.0.5"
 
 [features]
 default = [ "nightly", "instructions" ]

src/structures/idt.rs

@@ -410,39 +410,37 @@ pub struct InterruptDescriptorTable {
 }
 
 impl InterruptDescriptorTable {
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Creates a new IDT filled with non-present entries.
-        #[inline]
-        pub fn new() -> InterruptDescriptorTable {
-            InterruptDescriptorTable {
-                divide_error: Entry::missing(),
-                debug: Entry::missing(),
-                non_maskable_interrupt: Entry::missing(),
-                breakpoint: Entry::missing(),
-                overflow: Entry::missing(),
-                bound_range_exceeded: Entry::missing(),
-                invalid_opcode: Entry::missing(),
-                device_not_available: Entry::missing(),
-                double_fault: Entry::missing(),
-                coprocessor_segment_overrun: Entry::missing(),
-                invalid_tss: Entry::missing(),
-                segment_not_present: Entry::missing(),
-                stack_segment_fault: Entry::missing(),
-                general_protection_fault: Entry::missing(),
-                page_fault: Entry::missing(),
-                reserved_1: Entry::missing(),
-                x87_floating_point: Entry::missing(),
-                alignment_check: Entry::missing(),
-                machine_check: Entry::missing(),
-                simd_floating_point: Entry::missing(),
-                virtualization: Entry::missing(),
-                reserved_2: [Entry::missing(); 8],
-                vmm_communication_exception: Entry::missing(),
-                security_exception: Entry::missing(),
-                reserved_3: Entry::missing(),
-                interrupts: [Entry::missing(); 256 - 32],
-            }
+    /// Creates a new IDT filled with non-present entries.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn new() -> InterruptDescriptorTable {
+        InterruptDescriptorTable {
+            divide_error: Entry::missing(),
+            debug: Entry::missing(),
+            non_maskable_interrupt: Entry::missing(),
+            breakpoint: Entry::missing(),
+            overflow: Entry::missing(),
+            bound_range_exceeded: Entry::missing(),
+            invalid_opcode: Entry::missing(),
+            device_not_available: Entry::missing(),
+            double_fault: Entry::missing(),
+            coprocessor_segment_overrun: Entry::missing(),
+            invalid_tss: Entry::missing(),
+            segment_not_present: Entry::missing(),
+            stack_segment_fault: Entry::missing(),
+            general_protection_fault: Entry::missing(),
+            page_fault: Entry::missing(),
+            reserved_1: Entry::missing(),
+            x87_floating_point: Entry::missing(),
+            alignment_check: Entry::missing(),
+            machine_check: Entry::missing(),
+            simd_floating_point: Entry::missing(),
+            virtualization: Entry::missing(),
+            reserved_2: [Entry::missing(); 8],
+            vmm_communication_exception: Entry::missing(),
+            security_exception: Entry::missing(),
+            reserved_3: Entry::missing(),
+            interrupts: [Entry::missing(); 256 - 32],
         }
     }
 

src/structures/paging/frame.rs

@@ -30,19 +30,17 @@ impl<S: PageSize> PhysFrame<S> {
         Ok(unsafe { PhysFrame::from_start_address_unchecked(address) })
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the frame that starts at the given virtual address.
-        ///
-        /// ## Safety
-        ///
-        /// The address must be correctly aligned.
-        #[inline]
-        pub unsafe fn from_start_address_unchecked(start_address: PhysAddr) -> Self {
-            PhysFrame {
-                start_address,
-                size: PhantomData,
-            }
+    /// Returns the frame that starts at the given virtual address.
+    ///
+    /// ## Safety
+    ///
+    /// The address must be correctly aligned.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub unsafe fn from_start_address_unchecked(start_address: PhysAddr) -> Self {
+        PhysFrame {
+            start_address,
+            size: PhantomData,
         }
     }
 
@@ -55,40 +53,32 @@ impl<S: PageSize> PhysFrame<S> {
         }
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the start address of the frame.
-        #[inline]
-        pub fn start_address(self) -> PhysAddr {
-            self.start_address
-        }
+    /// Returns the start address of the frame.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn start_address(self) -> PhysAddr {
+        self.start_address
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the size the frame (4KB, 2MB or 1GB).
-        #[inline]
-        pub fn size(self) -> u64 {
-            S::SIZE
-        }
+    /// Returns the size the frame (4KB, 2MB or 1GB).
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn size(self) -> u64 {
+        S::SIZE
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns a range of frames, exclusive `end`.
-        #[inline]
-        pub fn range(start: PhysFrame<S>, end: PhysFrame<S>) -> PhysFrameRange<S> {
-            PhysFrameRange { start, end }
-        }
+    /// Returns a range of frames, exclusive `end`.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn range(start: PhysFrame<S>, end: PhysFrame<S>) -> PhysFrameRange<S> {
+        PhysFrameRange { start, end }
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns a range of frames, inclusive `end`.
-        #[inline]
-        pub fn range_inclusive(start: PhysFrame<S>, end: PhysFrame<S>) -> PhysFrameRangeInclusive<S> {
-            PhysFrameRangeInclusive { start, end }
-        }
+    /// Returns a range of frames, inclusive `end`.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn range_inclusive(start: PhysFrame<S>, end: PhysFrame<S>) -> PhysFrameRangeInclusive<S> {
+        PhysFrameRangeInclusive { start, end }
     }
 }
 

src/structures/paging/page.rs

@@ -77,19 +77,17 @@ impl<S: PageSize> Page<S> {
         Ok(Page::containing_address(address))
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the page that starts at the given virtual address.
-        ///
-        /// ## Safety
-        ///
-        /// The address must be correctly aligned.
-        #[inline]
-        pub unsafe fn from_start_address_unchecked(start_address: VirtAddr) -> Self {
-            Page {
-                start_address,
-                size: PhantomData,
-            }
+    /// Returns the page that starts at the given virtual address.
+    ///
+    /// ## Safety
+    ///
+    /// The address must be correctly aligned.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub unsafe fn from_start_address_unchecked(start_address: VirtAddr) -> Self {
+        Page {
+            start_address,
+            size: PhantomData,
         }
     }
 
@@ -102,78 +100,62 @@ impl<S: PageSize> Page<S> {
         }
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the start address of the page.
-        #[inline]
-        pub fn start_address(self) -> VirtAddr {
-            self.start_address
-        }
+    /// Returns the start address of the page.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn start_address(self) -> VirtAddr {
+        self.start_address
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the size the page (4KB, 2MB or 1GB).
-        #[inline]
-        pub fn size(self) -> u64 {
-            S::SIZE
-        }
+    /// Returns the size the page (4KB, 2MB or 1GB).
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn size(self) -> u64 {
+        S::SIZE
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the level 4 page table index of this page.
-        #[inline]
-        pub fn p4_index(self) -> PageTableIndex {
-            self.start_address().p4_index()
-        }
+    /// Returns the level 4 page table index of this page.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn p4_index(self) -> PageTableIndex {
+        self.start_address().p4_index()
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the level 3 page table index of this page.
-        #[inline]
-        pub fn p3_index(self) -> PageTableIndex {
-            self.start_address().p3_index()
-        }
+    /// Returns the level 3 page table index of this page.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn p3_index(self) -> PageTableIndex {
+        self.start_address().p3_index()
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the table index of this page at the specified level.
-        #[inline]
-        pub fn page_table_index(self, level: PageTableLevel) -> PageTableIndex {
-            self.start_address().page_table_index(level)
-        }
+    /// Returns the table index of this page at the specified level.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn page_table_index(self, level: PageTableLevel) -> PageTableIndex {
+        self.start_address().page_table_index(level)
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns a range of pages, exclusive `end`.
-        #[inline]
-        pub fn range(start: Self, end: Self) -> PageRange<S> {
-            PageRange { start, end }
-        }
+    /// Returns a range of pages, exclusive `end`.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn range(start: Self, end: Self) -> PageRange<S> {
+        PageRange { start, end }
     }
 
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns a range of pages, inclusive `end`.
-        #[inline]
-        pub fn range_inclusive(start: Self, end: Self) -> PageRangeInclusive<S> {
-            PageRangeInclusive { start, end }
-        }
+    /// Returns a range of pages, inclusive `end`.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn range_inclusive(start: Self, end: Self) -> PageRangeInclusive<S> {
+        PageRangeInclusive { start, end }
     }
 }
 
 impl<S: NotGiantPageSize> Page<S> {
-    // TODO: Remove const_fn! when our minimum supported stable Rust version is 1.61
-    const_fn! {
-        /// Returns the level 2 page table index of this page.
-        #[inline]
-        pub fn p2_index(self) -> PageTableIndex {
-            self.start_address().p2_index()
-        }
+    /// Returns the level 2 page table index of this page.
+    #[inline]
+    #[rustversion::attr(since(1.61), const)]
+    pub fn p2_index(self) -> PageTableIndex {
+        self.start_address().p2_index()
     }
 }