Remove unused arguments and general tidy up.

Author: aardvark179

src/main/java/org/truffleruby/RubyContext.java

@@ -189,8 +189,8 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
         codeLoader = new CodeLoader(language, this);
         featureLoader = new FeatureLoader(this, language);
         referenceProcessor = new ReferenceProcessor(this);
-        finalizationService = new FinalizationService(getLanguageSlow(), referenceProcessor);
-        markingService = new MarkingService(getLanguageSlow(), referenceProcessor);
+        finalizationService = new FinalizationService(referenceProcessor);
+        markingService = new MarkingService(referenceProcessor);
 
         // We need to construct this at runtime
         random = createRandomInstance();

src/main/java/org/truffleruby/RubyLanguage.java

@@ -208,7 +208,7 @@ private static final class ThreadLocalState {
     public final FrozenStringLiterals frozenStringLiterals;
 
     public final ReferenceQueue<Object> sharedReferenceQueue = new ReferenceQueue<>();
-    public final FinalizationService sharedFinzationService = new FinalizationService(this, sharedReferenceQueue);
+    public final FinalizationService sharedFinzationService = new FinalizationService(sharedReferenceQueue);
     public volatile ValueWrapperManager.HandleBlockWeakReference[] handleBlockSharedMap = new ValueWrapperManager.HandleBlockWeakReference[0];
     public final ValueWrapperManager.HandleBlockAllocator handleBlockAllocator = new ValueWrapperManager.HandleBlockAllocator();
 

src/main/java/org/truffleruby/cext/ValueWrapperManager.java

@@ -18,7 +18,6 @@
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.SuppressFBWarnings;
 import org.truffleruby.cext.ValueWrapperManagerFactory.AllocateHandleNodeGen;
-import org.truffleruby.core.fiber.RubyFiber;
 import org.truffleruby.extra.ffi.Pointer;
 import org.truffleruby.language.ImmutableRubyObject;
 import org.truffleruby.language.NotProvided;
@@ -60,18 +59,7 @@ public class ValueWrapperManager {
 
     private volatile HandleBlockWeakReference[] blockMap = new HandleBlockWeakReference[0];
 
-    public HandleBlockHolder makeThreadData(RubyContext context) {
-        HandleBlockHolder holder = new HandleBlockHolder();
-        context.getFinalizationService().addFinalizer(
-                context,
-                holder,
-                ValueWrapperManager.class,
-                () -> context.getMarkingService().queueForMarking(holder.handleBlock),
-                null);
-        return holder;
-    }
-
-    public HandleBlockHolder getBlockHolder(RubyContext context, RubyLanguage language) {
+    public static HandleBlockHolder getBlockHolder(RubyContext context, RubyLanguage language) {
         return language.getCurrentThread().getCurrentFiber().handleData;
     }
 
@@ -304,7 +292,7 @@ protected long allocateHandleOnKnownThread(ValueWrapper wrapper) {
                     wrapper,
                     getContext(),
                     getLanguage(),
-                    getContext().getValueWrapperManager().getBlockHolder(getContext(), getLanguage()),
+                    getBlockHolder(getContext(), getLanguage()),
                     false);
         }
 
@@ -314,7 +302,7 @@ protected long allocateSharedHandleOnKnownThread(ValueWrapper wrapper) {
                     wrapper,
                     getContext(),
                     getLanguage(),
-                    getContext().getValueWrapperManager().getBlockHolder(getContext(), getLanguage()),
+                    getBlockHolder(getContext(), getLanguage()),
                     true);
         }
 

src/main/java/org/truffleruby/core/FinalizationService.java

@@ -48,12 +48,12 @@ public RubyDynamicObject getRoot() {
         }
     }
 
-    public FinalizationService(RubyLanguage language, ReferenceQueue<Object> processingQueue) {
-        super(language, processingQueue);
+    public FinalizationService(ReferenceQueue<Object> processingQueue) {
+        super(processingQueue);
     }
 
-    public FinalizationService(RubyLanguage language, ReferenceProcessor referenceProcessor) {
-        this(language, referenceProcessor.processingQueue);
+    public FinalizationService(ReferenceProcessor referenceProcessor) {
+        this(referenceProcessor.processingQueue);
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/core/MarkingService.java

@@ -57,10 +57,9 @@ public static class MarkRunnerService extends ReferenceProcessingService<Marking
         private final MarkingService markingService;
 
         public MarkRunnerService(
-                RubyLanguage language,
                 ReferenceQueue<Object> processingQueue,
                 MarkingService markingService) {
-            super(language, processingQueue);
+            super(processingQueue);
             this.markingService = markingService;
         }
 
@@ -157,13 +156,13 @@ public Object getBlock() {
         }
     }
 
-    public MarkingService(RubyLanguage language, ReferenceProcessor referenceprocessor) {
-        this(language, referenceprocessor.processingQueue);
+    public MarkingService(ReferenceProcessor referenceprocessor) {
+        this(referenceprocessor.processingQueue);
     }
 
-    public MarkingService(RubyLanguage language, ReferenceQueue<Object> processingQueue) {
-        super(language, processingQueue);
-        runnerService = new MarkRunnerService(language, processingQueue, this);
+    public MarkingService(ReferenceQueue<Object> processingQueue) {
+        super(processingQueue);
+        runnerService = new MarkRunnerService(processingQueue, this);
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/core/ReferenceProcessingService.java

@@ -253,7 +253,7 @@ protected final void drainReferenceQueues() {
 
     protected final ReferenceQueue<Object> processingQueue;
 
-    public ReferenceProcessingService(RubyLanguage language, ReferenceQueue<Object> processingQueue) {
+    public ReferenceProcessingService(ReferenceQueue<Object> processingQueue) {
         this.processingQueue = processingQueue;
     }
 
@@ -262,12 +262,12 @@ protected void processReference(RubyContext context, RubyLanguage language, Proc
         remove((R) reference);
     }
 
-    public interface ReferenceRunner<T, U, V> {
-        public void accept(T t, U u, V v);
+    public interface ReferenceRunner<T> {
+        public void accept(RubyContext context, RubyLanguage language, T t);
     }
 
     protected void runCatchingErrors(RubyContext context, RubyLanguage language,
-            ReferenceRunner<RubyContext, RubyLanguage, R> action, R reference) {
+            ReferenceRunner<R> action, R reference) {
         try {
             action.accept(context, language, reference);
         } catch (TerminationException e) {