Refactor to make handle block cleanable final.

Author: aardvark179

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

@@ -78,34 +78,25 @@ public ValueWrapper doubleWrapper(double value) {
     }
 
     @TruffleBoundary
-    public synchronized void addToBlockMap(HandleBlock block, RubyContext context, RubyLanguage language) {
+    public synchronized HandleBlock addToBlockMap(RubyContext context, RubyLanguage language) {
+        HandleBlock block = new HandleBlock(context, language, this);
         int blockIndex = block.getIndex();
-        long blockBase = block.getBase();
-        HandleBlockAllocator allocator = language.handleBlockAllocator;
         HandleBlockWeakReference[] map = growMapIfRequired(blockMap, blockIndex);
         blockMap = map;
         map[blockIndex] = new HandleBlockWeakReference(block);
 
-        block.cleanable = RubyLanguage.cleaner.register(block, () -> {
-            this.blockMap[blockIndex] = null;
-            allocator.addFreeBlock(blockBase);
-        });
+        return block;
     }
 
     @TruffleBoundary
-    public void addToSharedBlockMap(HandleBlock block, RubyContext context, RubyLanguage language) {
+    public HandleBlock addToSharedBlockMap(RubyContext context, RubyLanguage language) {
         synchronized (language) {
+            HandleBlock block = new HandleBlock(context, language, this);
             int blockIndex = block.getIndex();
-            long blockBase = block.getBase();
-            HandleBlockAllocator allocator = language.handleBlockAllocator;
             HandleBlockWeakReference[] map = growMapIfRequired(language.handleBlockSharedMap, blockIndex);
             language.handleBlockSharedMap = map;
             map[blockIndex] = new HandleBlockWeakReference(block);
-
-            block.cleanable = RubyLanguage.cleaner.register(block, () -> {
-                language.handleBlockSharedMap[blockIndex] = null;
-                allocator.addFreeBlock(blockBase);
-            });
+            return block;
         }
     }
 
@@ -218,27 +209,39 @@ public synchronized void addFreeBlock(long blockBase) {
 
     public static class HandleBlock {
 
-        public static final HandleBlock DUMMY_BLOCK = new HandleBlock(null, 0, null);
+        public static final HandleBlock DUMMY_BLOCK = new HandleBlock();
 
         private static final Set<HandleBlock> keepAlive = ConcurrentHashMap.newKeySet();
 
         private final long base;
         @SuppressWarnings("rawtypes") private final ValueWrapper[] wrappers;
         private int count;
 
-        private Cleanable cleanable;
+        @SuppressWarnings("unused") private Cleanable cleanable;
 
-        public HandleBlock(RubyContext context, HandleBlockAllocator allocator) {
-            this(context, allocator.getFreeBlock(), new ValueWrapper[BLOCK_SIZE]);
+        private HandleBlock() {
+            base = 0;
+            cleanable = null;
+            wrappers = null;
         }
 
-        private HandleBlock(RubyContext context, long base, ValueWrapper[] wrappers) {
+        public HandleBlock(RubyContext context, RubyLanguage language, ValueWrapperManager manager) {
+            HandleBlockAllocator allocator = language.handleBlockAllocator;
+            long base = allocator.getFreeBlock();
             if (context != null && context.getOptions().CEXTS_KEEP_HANDLES_ALIVE) {
                 keepAlive(this);
             }
             this.base = base;
-            this.wrappers = wrappers;
+            this.wrappers = new ValueWrapper[BLOCK_SIZE];
             this.count = 0;
+            this.cleanable = RubyLanguage.cleaner.register(this, HandleBlock.makeCleaner(manager, base, allocator));
+        }
+
+        private static Runnable makeCleaner(ValueWrapperManager manager, long base, HandleBlockAllocator allocator) {
+            return () -> {
+                manager.blockMap[(int) ((base - ALLOCATION_BASE) >> BLOCK_BITS)] = null;
+                allocator.addFreeBlock(base);
+            };
         }
 
         @TruffleBoundary
@@ -330,11 +333,11 @@ protected static long allocateHandle(ValueWrapper wrapper, RubyContext context,
                     context.getMarkingService().queueForMarking(block);
                 }
                 if (shared) {
-                    block = (holder.sharedHandleBlock = new HandleBlock(context, language.handleBlockAllocator));
-                    context.getValueWrapperManager().addToSharedBlockMap(block, context, language);
+                    block = context.getValueWrapperManager().addToSharedBlockMap(context, language);
+                    holder.sharedHandleBlock = block;
                 } else {
-                    block = (holder.handleBlock = new HandleBlock(context, language.handleBlockAllocator));
-                    context.getValueWrapperManager().addToBlockMap(block, context, language);
+                    block = context.getValueWrapperManager().addToBlockMap(context, language);
+                    holder.handleBlock = block;
                 }
 
             }
@@ -357,9 +360,9 @@ public static HandleBlock allocateNewBlock(RubyContext context, RubyLanguage lan
         if (block != null) {
             context.getMarkingService().queueForMarking(block);
         }
-        block = (holder.handleBlock = new HandleBlock(context, language.handleBlockAllocator));
-        context.getValueWrapperManager().addToBlockMap(block, context, language);
+        block = context.getValueWrapperManager().addToBlockMap(context, language);
 
+        holder.handleBlock = block;
         return block;
     }