diff --git a/src/context/memory.rs b/src/context/memory.rs
index 37b0ec4d79..6a07d3784e 100644
--- a/src/context/memory.rs
+++ b/src/context/memory.rs
@@ -158,16 +158,16 @@ impl AddrSpace {
         }
         Ok(())
     }
-    pub fn munmap(mut self: RwLockWriteGuard<'_, Self>, page: Page, page_count: usize) {
+    pub fn munmap(mut this: RwLockWriteGuard<'_, Self>, page: Page, page_count: usize) {
         let mut notify_files = Vec::new();
 
         let requested = Region::new(page.start_address(), page_count * PAGE_SIZE);
         let mut flusher = PageFlushAll::new();
 
-        let conflicting: Vec<Region> = self.grants.conflicts(requested).map(Region::from).collect();
+        let conflicting: Vec<Region> = this.grants.conflicts(requested).map(Region::from).collect();
 
         for conflict in conflicting {
-            let grant = self.grants.take(&conflict).expect("conflicting region didn't exist");
+            let grant = this.grants.take(&conflict).expect("conflicting region didn't exist");
             let intersection = grant.intersect(requested);
             let (before, mut grant, after) = grant.extract(intersection.round()).expect("conflicting region shared no common parts");
 
@@ -178,16 +178,16 @@ impl AddrSpace {
 
             // Keep untouched regions
             if let Some(before) = before {
-                self.grants.insert(before);
+                this.grants.insert(before);
             }
             if let Some(after) = after {
-                self.grants.insert(after);
+                this.grants.insert(after);
             }
 
             // Remove irrelevant region
-            grant.unmap(&mut self.table.utable, &mut flusher);
+            grant.unmap(&mut this.table.utable, &mut flusher);
         }
-        drop(self);
+        drop(this);
 
         for (file_ref, intersection) in notify_files {
             let scheme_id = { file_ref.desc.description.read().scheme };
diff --git a/src/lib.rs b/src/lib.rs
index 55c27329fb..ec53c4e479 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,7 +44,6 @@
 
 #![feature(alloc_error_handler)]
 #![feature(allocator_api)]
-#![feature(arbitrary_self_types)]
 #![feature(array_chunks)]
 #![feature(iter_array_chunks)]
 #![feature(asm_const)] // TODO: Relax requirements of most asm invocations
diff --git a/src/scheme/proc.rs b/src/scheme/proc.rs
index df2d2633c5..e57894df20 100644
--- a/src/scheme/proc.rs
+++ b/src/scheme/proc.rs
@@ -1030,7 +1030,7 @@ impl KernelScheme for ProcScheme {
                     ADDRSPACE_OP_MUNMAP => {
                         let (page, page_count) = crate::syscall::validate_region(next()??, next()??)?;
 
-                        addrspace.write().munmap(page, page_count);
+                        AddrSpace::munmap(addrspace.write(), page, page_count);
                     }
                     ADDRSPACE_OP_MPROTECT => {
                         let (page, page_count) = crate::syscall::validate_region(next()??, next()??)?;
diff --git a/src/scheme/user.rs b/src/scheme/user.rs
index 391fe3159f..5efd212664 100644
--- a/src/scheme/user.rs
+++ b/src/scheme/user.rs
@@ -532,7 +532,7 @@ impl<const READ: bool, const WRITE: bool> CaptureGuard<READ, WRITE> {
 
         let (first_page, page_count, _offset) = page_range_containing(self.base, self.len);
 
-        space.write().munmap(first_page, page_count);
+        AddrSpace::munmap(space.write(), first_page, page_count);
 
         result
     }
diff --git a/src/syscall/fs.rs b/src/syscall/fs.rs
index 2661ef5e8b..2f6e185fb6 100644
--- a/src/syscall/fs.rs
+++ b/src/syscall/fs.rs
@@ -3,6 +3,7 @@ use alloc::sync::Arc;
 use spin::RwLock;
 
 use crate::context::file::{FileDescriptor, FileDescription};
+use crate::context::memory::AddrSpace;
 use crate::context;
 use crate::memory::PAGE_SIZE;
 use crate::scheme::{self, FileHandle, OpenResult, current_caller_ctx, KernelScheme, SchemeId};
@@ -394,7 +395,7 @@ pub fn funmap(virtual_address: usize, length: usize) -> Result<usize> {
     let (page, page_count) = crate::syscall::validate_region(virtual_address, length_aligned)?;
 
     let addr_space = Arc::clone(context::current()?.read().addr_space()?);
-    addr_space.write().munmap(page, page_count);
+    AddrSpace::munmap(addr_space.write(), page, page_count);
 
     Ok(0)
 }