Remove dead trace_object methods. (mmtk#1277)

Now that we are using the `#[derive(HasSpaces, PlanTraceObject)]` derive
macros to generate the trace_object methods, we can remove the
manually-written dead code.

Author: wks

docs/userguide/src/tutorial/code/mygc_semispace/gc_work.rs

@@ -73,7 +73,9 @@ impl<VM: VMBinding> ProcessEdgesWork for MyGCProcessEdges<VM> {
                 worker,
             )
         } else {
-            self.plan.common.trace_object(queue, object, worker)
+            use crate::plan::PlanTraceObject;
+            use crate::policy::gc_work::DEFAULT_TRACE;
+            self.plan.common.trace_object::<_, DEFAULT_TRACE>(queue, object, worker)
         }
     }
 

src/plan/generational/global.rs

@@ -202,25 +202,6 @@ impl<VM: VMBinding> CommonGenPlan<VM> {
         is_full_heap
     }
 
-    /// Trace objects for spaces in generational and common plans for a full heap GC.
-    #[allow(unused)] // We now use `PlanTraceObject`, and this mehtod is not used.
-    pub fn trace_object_full_heap<Q: ObjectQueue>(
-        &self,
-        queue: &mut Q,
-        object: ObjectReference,
-        worker: &mut GCWorker<VM>,
-    ) -> ObjectReference {
-        if self.nursery.in_space(object) {
-            return self.nursery.trace_object::<Q>(
-                queue,
-                object,
-                Some(CopySemantics::PromoteToMature),
-                worker,
-            );
-        }
-        self.common.trace_object::<Q>(queue, object, worker)
-    }
-
     /// Trace objects for spaces in generational and common plans for a nursery GC.
     pub fn trace_object_nursery<Q: ObjectQueue, const KIND: TraceKind>(
         &self,

src/plan/global.rs

@@ -489,39 +489,6 @@ impl<VM: VMBinding> BasePlan<VM> {
         pages
     }
 
-    pub fn trace_object<Q: ObjectQueue>(
-        &self,
-        queue: &mut Q,
-        object: ObjectReference,
-        worker: &mut GCWorker<VM>,
-    ) -> ObjectReference {
-        #[cfg(feature = "code_space")]
-        if self.code_space.in_space(object) {
-            trace!("trace_object: object in code space");
-            return self.code_space.trace_object::<Q>(queue, object);
-        }
-
-        #[cfg(feature = "code_space")]
-        if self.code_lo_space.in_space(object) {
-            trace!("trace_object: object in large code space");
-            return self.code_lo_space.trace_object::<Q>(queue, object);
-        }
-
-        #[cfg(feature = "ro_space")]
-        if self.ro_space.in_space(object) {
-            trace!("trace_object: object in ro_space space");
-            return self.ro_space.trace_object(queue, object);
-        }
-
-        #[cfg(feature = "vm_space")]
-        if self.vm_space.in_space(object) {
-            trace!("trace_object: object in boot space");
-            return self.vm_space.trace_object(queue, object);
-        }
-
-        VM::VMActivePlan::vm_trace_object::<Q>(queue, object, worker)
-    }
-
     pub fn prepare(&mut self, _tls: VMWorkerThread, _full_heap: bool) {
         #[cfg(feature = "code_space")]
         self.code_space.prepare();
@@ -621,27 +588,6 @@ impl<VM: VMBinding> CommonPlan<VM> {
             + self.base.get_used_pages()
     }
 
-    pub fn trace_object<Q: ObjectQueue>(
-        &self,
-        queue: &mut Q,
-        object: ObjectReference,
-        worker: &mut GCWorker<VM>,
-    ) -> ObjectReference {
-        if self.immortal.in_space(object) {
-            trace!("trace_object: object in immortal space");
-            return self.immortal.trace_object(queue, object);
-        }
-        if self.los.in_space(object) {
-            trace!("trace_object: object in los");
-            return self.los.trace_object(queue, object);
-        }
-        if self.nonmoving.in_space(object) {
-            trace!("trace_object: object in nonmoving space");
-            return self.nonmoving.trace_object(queue, object);
-        }
-        self.base.trace_object::<Q>(queue, object, worker)
-    }
-
     pub fn prepare(&mut self, tls: VMWorkerThread, full_heap: bool) {
         self.immortal.prepare();
         self.los.prepare(full_heap);