Bump Rust version to v1.66.1 (#752)

k-sareen · web-flow · commit 5b48f8ad2e62 · 2023-02-08T14:29:38.000+11:00
diff --git a/rust-toolchain b/rust-toolchain
@@ -1 +1 @@
-1.59.0
+1.66.1
diff --git a/src/plan/generational/copying/global.rs b/src/plan/generational/copying/global.rs
@@ -95,7 +95,7 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/generational/copying/mutator.rs b/src/plan/generational/copying/mutator.rs
@@ -34,7 +34,7 @@ pub fn create_gencopy_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let gencopy = mmtk.plan.downcast_ref::<GenCopy<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new(create_gen_space_mapping(&*mmtk.plan, &gencopy.gen.nursery)),
         prepare_func: &gencopy_mutator_prepare,
         release_func: &gencopy_mutator_release,
diff --git a/src/plan/generational/immix/global.rs b/src/plan/generational/immix/global.rs
@@ -144,7 +144,7 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*super::mutator::ALLOCATOR_MAPPING
+        &super::mutator::ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/generational/immix/mutator.rs b/src/plan/generational/immix/mutator.rs
@@ -32,7 +32,7 @@ pub fn create_genimmix_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let genimmix = mmtk.plan.downcast_ref::<GenImmix<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new(create_gen_space_mapping(&*mmtk.plan, &genimmix.gen.nursery)),
         prepare_func: &genimmix_mutator_prepare,
         release_func: &genimmix_mutator_release,
diff --git a/src/plan/immix/global.rs b/src/plan/immix/global.rs
@@ -99,7 +99,7 @@ impl<VM: VMBinding> Plan for Immix<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/immix/mutator.rs b/src/plan/immix/mutator.rs
@@ -56,7 +56,7 @@ pub fn create_immix_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let immix = plan.downcast_ref::<Immix<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new({
             let mut vec = create_space_mapping(RESERVED_ALLOCATORS, true, plan);
             vec.push((AllocatorSelector::Immix(0), &immix.immix_space));
diff --git a/src/plan/markcompact/global.rs b/src/plan/markcompact/global.rs
@@ -76,7 +76,7 @@ impl<VM: VMBinding> Plan for MarkCompact<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn schedule_collection(&'static self, scheduler: &GCWorkScheduler<VM>) {
diff --git a/src/plan/markcompact/mutator.rs b/src/plan/markcompact/mutator.rs
@@ -32,7 +32,7 @@ pub fn create_markcompact_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let markcompact = plan.downcast_ref::<MarkCompact<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new({
             let mut vec = create_space_mapping(RESERVED_ALLOCATORS, true, plan);
             vec.push((AllocatorSelector::MarkCompact(0), markcompact.mc_space()));
diff --git a/src/plan/marksweep/global.rs b/src/plan/marksweep/global.rs
@@ -62,7 +62,7 @@ impl<VM: VMBinding> Plan for MarkSweep<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/marksweep/mutator.rs b/src/plan/marksweep/mutator.rs
@@ -114,7 +114,7 @@ pub fn create_ms_mutator<VM: VMBinding>(
     plan: &'static dyn Plan<VM = VM>,
 ) -> Mutator<VM> {
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: create_space_mapping(plan),
         prepare_func: &ms_mutator_prepare,
         release_func: &ms_mutator_release,
diff --git a/src/plan/nogc/global.rs b/src/plan/nogc/global.rs
@@ -62,7 +62,7 @@ impl<VM: VMBinding> Plan for NoGC<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn schedule_collection(&'static self, _scheduler: &GCWorkScheduler<VM>) {
diff --git a/src/plan/nogc/mutator.rs b/src/plan/nogc/mutator.rs
@@ -45,7 +45,7 @@ pub fn create_nogc_mutator<VM: VMBinding>(
     plan: &'static dyn Plan<VM = VM>,
 ) -> Mutator<VM> {
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new({
             let mut vec = create_space_mapping(MULTI_SPACE_RESERVED_ALLOCATORS, false, plan);
             vec.push((
diff --git a/src/plan/pageprotect/global.rs b/src/plan/pageprotect/global.rs
@@ -52,7 +52,7 @@ impl<VM: VMBinding> Plan for PageProtect<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/pageprotect/mutator.rs b/src/plan/pageprotect/mutator.rs
@@ -41,7 +41,7 @@ pub fn create_pp_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let page = plan.downcast_ref::<PageProtect<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new({
             let mut vec = create_space_mapping(RESERVED_ALLOCATORS, true, plan);
             vec.push((AllocatorSelector::LargeObject(0), &page.space));
diff --git a/src/plan/semispace/global.rs b/src/plan/semispace/global.rs
@@ -79,7 +79,7 @@ impl<VM: VMBinding> Plan for SemiSpace<VM> {
     }
 
     fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
-        &*ALLOCATOR_MAPPING
+        &ALLOCATOR_MAPPING
     }
 
     fn prepare(&mut self, tls: VMWorkerThread) {
diff --git a/src/plan/semispace/mutator.rs b/src/plan/semispace/mutator.rs
@@ -54,7 +54,7 @@ pub fn create_ss_mutator<VM: VMBinding>(
 ) -> Mutator<VM> {
     let ss = plan.downcast_ref::<SemiSpace<VM>>().unwrap();
     let config = MutatorConfig {
-        allocator_mapping: &*ALLOCATOR_MAPPING,
+        allocator_mapping: &ALLOCATOR_MAPPING,
         space_mapping: Box::new({
             let mut vec = create_space_mapping(RESERVED_ALLOCATORS, true, plan);
             vec.push((AllocatorSelector::BumpPointer(0), ss.tospace()));
diff --git a/src/policy/immix/defrag.rs b/src/policy/immix/defrag.rs
@@ -182,7 +182,7 @@ impl Defrag {
             // Calculate the number of free lines in this bucket.
             let this_bucket_avail = spill_avail_histograms[threshold] as isize;
             // Update counters
-            limit -= this_bucket_avail as isize;
+            limit -= this_bucket_avail;
             required_lines += this_bucket_mark;
             // Stop scanning. Lines to evacuate exceeds the free to-space lines.
             if limit < required_lines {
diff --git a/src/policy/marksweepspace/malloc_ms/metadata.rs b/src/policy/marksweepspace/malloc_ms/metadata.rs
@@ -283,5 +283,5 @@ pub(super) unsafe fn load128(metadata_spec: &SideMetadataSpec, data_addr: Addres
     #[cfg(debug_assertions)]
     metadata_spec.assert_metadata_mapped(data_addr);
 
-    meta_addr.load::<u128>() as u128
+    meta_addr.load::<u128>()
 }
diff --git a/src/policy/marksweepspace/native_ms/block.rs b/src/policy/marksweepspace/native_ms/block.rs
@@ -184,7 +184,7 @@ impl Block {
     pub fn load_block_list(&self) -> *mut BlockList {
         let block_list =
             Block::BLOCK_LIST_TABLE.load_atomic::<usize>(self.start(), Ordering::SeqCst);
-        unsafe { std::mem::transmute::<usize, *mut BlockList>(block_list) }
+        block_list as *mut BlockList
     }
 
     pub fn load_block_cell_size(&self) -> usize {
diff --git a/src/policy/marksweepspace/native_ms/global.rs b/src/policy/marksweepspace/native_ms/global.rs
@@ -174,6 +174,8 @@ impl<VM: VMBinding> crate::policy::gc_work::PolicyTraceObject<VM> for MarkSweepS
 pub const MAX_OBJECT_SIZE: usize = crate::policy::marksweepspace::native_ms::MI_LARGE_OBJ_SIZE_MAX;
 
 impl<VM: VMBinding> MarkSweepSpace<VM> {
+    // Allow ptr_arg as we want to keep the function signature the same as for malloc marksweep
+    #[allow(clippy::ptr_arg)]
     pub fn extend_global_side_metadata_specs(_specs: &mut Vec<SideMetadataSpec>) {
         // MarkSweepSpace does not need any special global specs. This method exists, as
         // we need this method for MallocSpace, and we want those two spaces to be used interchangably.
diff --git a/src/scheduler/work_bucket.rs b/src/scheduler/work_bucket.rs
@@ -43,12 +43,14 @@ impl<VM: VMBinding> BucketQueue<VM> {
     }
 }
 
+pub type BucketOpenCondition<VM> = Box<dyn (Fn(&GCWorkScheduler<VM>) -> bool) + Send>;
+
 pub struct WorkBucket<VM: VMBinding> {
     active: AtomicBool,
     queue: BucketQueue<VM>,
     prioritized_queue: Option<BucketQueue<VM>>,
     monitor: Arc<(Mutex<()>, Condvar)>,
-    can_open: Option<Box<dyn (Fn(&GCWorkScheduler<VM>) -> bool) + Send>>,
+    can_open: Option<BucketOpenCondition<VM>>,
     /// After this bucket is activated and all pending work packets (including the packets in this
     /// bucket) are drained, this work packet, if exists, will be added to this bucket.  When this
     /// happens, it will prevent opening subsequent work packets.
diff --git a/src/util/conversions.rs b/src/util/conversions.rs
@@ -102,7 +102,7 @@ pub fn bytes_to_formatted_string(bytes: usize) -> String {
         num = new_num;
         i += 1;
     }
-    return format!("{}{}", num, UNITS.last().unwrap());
+    format!("{}{}", num, UNITS.last().unwrap())
 }
 
 #[cfg(test)]
diff --git a/src/util/heap/blockpageresource.rs b/src/util/heap/blockpageresource.rs
@@ -279,7 +279,7 @@ impl<B: Region> BlockQueue<B> {
         new_array.cursor.store(temp, Ordering::Relaxed);
         // Swap data
         unsafe {
-            std::mem::swap(&mut *self.data.get(), &mut *new_array.data.get());
+            core::ptr::swap(self.data.get(), new_array.data.get());
         }
         // Return old array
         new_array
diff --git a/src/util/heap/layout/vm_layout_constants.rs b/src/util/heap/layout/vm_layout_constants.rs
@@ -27,7 +27,7 @@ pub const BYTES_IN_CHUNK: usize = 1 << LOG_BYTES_IN_CHUNK;
 pub const CHUNK_MASK: usize = (1 << LOG_BYTES_IN_CHUNK) - 1;
 
 /** Coarsest unit of address space allocation, in pages */
-pub const PAGES_IN_CHUNK: usize = 1 << (LOG_BYTES_IN_CHUNK as usize - LOG_BYTES_IN_PAGE as usize);
+pub const PAGES_IN_CHUNK: usize = 1 << (LOG_BYTES_IN_CHUNK - LOG_BYTES_IN_PAGE as usize);
 
 /** log_2 of the maximum number of chunks we need to track.  Only used in 32-bit layout.*/
 pub const LOG_MAX_CHUNKS: usize = LOG_ADDRESS_SPACE - LOG_BYTES_IN_CHUNK;
@@ -112,7 +112,7 @@ pub const LOG_MMAP_CHUNK_BYTES: usize = LOG_BYTES_IN_CHUNK;
 pub const MMAP_CHUNK_BYTES: usize = 1 << LOG_MMAP_CHUNK_BYTES;
 
 /** log_2 of the number of pages in a 64-bit space */
-pub const LOG_PAGES_IN_SPACE64: usize = LOG_SPACE_SIZE_64 as usize - LOG_BYTES_IN_PAGE as usize;
+pub const LOG_PAGES_IN_SPACE64: usize = LOG_SPACE_SIZE_64 - LOG_BYTES_IN_PAGE as usize;
 
 /** The number of pages in a 64-bit space */
 pub const PAGES_IN_SPACE64: usize = 1 << LOG_PAGES_IN_SPACE64;
diff --git a/src/util/malloc/malloc_ms_util.rs b/src/util/malloc/malloc_ms_util.rs
@@ -26,7 +26,7 @@ pub fn align_offset_alloc<VM: VMBinding>(size: usize, align: usize, offset: isiz
     if address.is_zero() {
         return address;
     }
-    let mod_offset = (offset % (align as isize)) as isize;
+    let mod_offset = offset % (align as isize);
     let mut result =
         crate::util::alloc::allocator::align_allocation_no_fill::<VM>(address, align, mod_offset);
     if result - BYTES_IN_ADDRESS < address {
diff --git a/src/util/metadata/side_metadata/helpers.rs b/src/util/metadata/side_metadata/helpers.rs
@@ -18,7 +18,7 @@ pub(crate) fn address_to_contiguous_meta_address(
     data_addr: Address,
 ) -> Address {
     let log_bits_num = metadata_spec.log_num_of_bits as i32;
-    let log_bytes_in_region = metadata_spec.log_bytes_in_region as usize;
+    let log_bytes_in_region = metadata_spec.log_bytes_in_region;
 
     let rshift = (LOG_BITS_IN_BYTE as i32) - log_bits_num;
 
diff --git a/src/util/metadata/side_metadata/helpers_32.rs b/src/util/metadata/side_metadata/helpers_32.rs
@@ -21,7 +21,7 @@ pub(super) fn address_to_chunked_meta_address(
     data_addr: Address,
 ) -> Address {
     let log_bits_num = metadata_spec.log_num_of_bits as i32;
-    let log_bytes_in_region = metadata_spec.log_bytes_in_region as usize;
+    let log_bytes_in_region = metadata_spec.log_bytes_in_region;
 
     let rshift = (LOG_BITS_IN_BYTE as i32) - log_bits_num;
 
diff --git a/src/util/metadata/side_metadata/side_metadata_tests.rs b/src/util/metadata/side_metadata/side_metadata_tests.rs
@@ -612,7 +612,7 @@ mod tests {
 
                     // First 9 regions
                     let regions = (0..9)
-                        .map(|i| data_addr + (region_size * i) as usize)
+                        .map(|i| data_addr + (region_size * i))
                         .collect::<Vec<Address>>();
                     // Set metadata for the regions
                     regions
@@ -669,7 +669,7 @@ mod tests {
 
                     // First 9 regions
                     let regions = (0..9)
-                        .map(|i| data_addr + (region_size * i) as usize)
+                        .map(|i| data_addr + (region_size * i))
                         .collect::<Vec<Address>>();
                     // Set metadata for the regions
                     regions
diff --git a/src/util/metadata/side_metadata/spec_defs.rs b/src/util/metadata/side_metadata/spec_defs.rs
@@ -57,9 +57,9 @@ define_side_metadata_specs!(
     // Mark the start of an object
     ALLOC_BIT       = (global: true, log_num_of_bits: 0, log_bytes_in_region: LOG_MIN_OBJECT_SIZE as usize),
     // Track chunks used by (malloc) marksweep
-    MS_ACTIVE_CHUNK = (global: true, log_num_of_bits: 3, log_bytes_in_region: LOG_BYTES_IN_CHUNK as usize),
+    MS_ACTIVE_CHUNK = (global: true, log_num_of_bits: 3, log_bytes_in_region: LOG_BYTES_IN_CHUNK),
     // Track the index in SFT map for a chunk (only used for SFT sparse chunk map)
-    SFT_DENSE_CHUNK_MAP_INDEX   = (global: true, log_num_of_bits: 3, log_bytes_in_region: LOG_BYTES_IN_CHUNK as usize),
+    SFT_DENSE_CHUNK_MAP_INDEX   = (global: true, log_num_of_bits: 3, log_bytes_in_region: LOG_BYTES_IN_CHUNK),
 );
 
 // This defines all LOCAL side metadata used by mmtk-core.
diff --git a/src/util/object_forwarding.rs b/src/util/object_forwarding.rs
@@ -94,7 +94,7 @@ pub fn forward_object<VM: VMBinding>(
         write_forwarding_pointer::<VM>(object, new_object);
         VM::VMObjectModel::LOCAL_FORWARDING_BITS_SPEC.store_atomic::<VM, u8>(
             object,
-            FORWARDED as u8,
+            FORWARDED,
             None,
             Ordering::SeqCst,
         );
diff --git a/src/util/options.rs b/src/util/options.rs
@@ -934,7 +934,7 @@ mod tests {
                     cpu_list.push('0');
                     for cpu in 1..num_cpus {
                         cpu_list.push_str(format!(",{}", cpu).as_str());
-                        vec.push(cpu as u16);
+                        vec.push(cpu);
                     }
 
                     std::env::set_var("MMTK_THREAD_AFFINITY", cpu_list);
diff --git a/src/util/raw_memory_freelist.rs b/src/util/raw_memory_freelist.rs
@@ -75,13 +75,13 @@ impl RawMemoryFreeList {
         (conversions::pages_to_bytes(self.pages_per_block as _) >> LOG_BYTES_IN_UNIT) as _
     }
     fn units_in_first_block(&self) -> i32 {
-        self.units_per_block() - (self.heads as i32) - 1
+        self.units_per_block() - self.heads - 1
     }
     pub fn default_block_size(units: i32, heads: i32) -> i32 {
         usize::min(Self::size_in_pages(units, heads) as _, 16) as _
     }
     pub fn size_in_pages(units: i32, heads: i32) -> i32 {
-        let map_size = ((units + heads + 1) as usize) << LOG_BYTES_IN_UNIT as usize;
+        let map_size = ((units + heads + 1) as usize) << LOG_BYTES_IN_UNIT;
         conversions::bytes_to_pages_up(map_size as _) as _
     }
 
diff --git a/src/util/statistics/counter/event_counter.rs b/src/util/statistics/counter/event_counter.rs
@@ -107,7 +107,7 @@ impl Counter for EventCounter {
             }
             Some(m) => {
                 let mut total = 0;
-                let mut p = if m { 0 } else { 1 };
+                let mut p = !m as usize;
                 while p <= self.stats.get_phase() {
                     total += self.count[p];
                     p += 2;
@@ -122,7 +122,7 @@ impl Counter for EventCounter {
     }
 
     fn print_min(&self, other: bool) {
-        let mut p = if other { 0 } else { 1 };
+        let mut p = !other as usize;
         let mut min = self.count[p];
         while p < self.stats.get_phase() {
             if self.count[p] < min {
@@ -134,7 +134,7 @@ impl Counter for EventCounter {
     }
 
     fn print_max(&self, other: bool) {
-        let mut p = if other { 0 } else { 1 };
+        let mut p = !other as usize;
         let mut max = self.count[p];
         while p < self.stats.get_phase() {
             if self.count[p] > max {
diff --git a/src/util/statistics/counter/long_counter.rs b/src/util/statistics/counter/long_counter.rs
@@ -69,7 +69,7 @@ impl<T: Diffable> Counter for LongCounter<T> {
             None => self.total_count,
             Some(m) => {
                 let mut total = 0;
-                let mut p = if m { 0 } else { 1 };
+                let mut p = !m as usize;
                 while p <= self.stats.get_phase() {
                     total += self.count[p];
                     p += 2;
@@ -84,7 +84,7 @@ impl<T: Diffable> Counter for LongCounter<T> {
     }
 
     fn print_min(&self, other: bool) {
-        let mut p = if other { 0 } else { 1 };
+        let mut p = !other as usize;
         let mut min = self.count[p];
         while p < self.stats.get_phase() {
             if self.count[p] < min {
@@ -96,7 +96,7 @@ impl<T: Diffable> Counter for LongCounter<T> {
     }
 
     fn print_max(&self, other: bool) {
-        let mut p = if other { 0 } else { 1 };
+        let mut p = !other as usize;
         let mut max = self.count[p];
         while p < self.stats.get_phase() {
             if self.count[p] > max {

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {`
`98`		`- &*ALLOCATOR_MAPPING`
	`98`	`+ &ALLOCATOR_MAPPING`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`fn prepare(&mut self, tls: VMWorkerThread) {`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {`
`147`		`- &*super::mutator::ALLOCATOR_MAPPING`
	`147`	`+ &super::mutator::ALLOCATOR_MAPPING`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`fn prepare(&mut self, tls: VMWorkerThread) {`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ impl<VM: VMBinding> Plan for Immix<VM> {`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {`
`102`		`- &*ALLOCATOR_MAPPING`
	`102`	`+ &ALLOCATOR_MAPPING`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`fn prepare(&mut self, tls: VMWorkerThread) {`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ impl<VM: VMBinding> Plan for MarkCompact<VM> {`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {`
`79`		`- &*ALLOCATOR_MAPPING`
	`79`	`+ &ALLOCATOR_MAPPING`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`fn schedule_collection(&'static self, scheduler: &GCWorkScheduler<VM>) {`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ impl<VM: VMBinding> Plan for MarkSweep<VM> {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {`
`65`		`- &*ALLOCATOR_MAPPING`
	`65`	`+ &ALLOCATOR_MAPPING`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`fn prepare(&mut self, tls: VMWorkerThread) {`