Further small changes to getting the wrapper from a native pointer.

Author: aardvark179

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

@@ -10,10 +10,14 @@
 package org.truffleruby.cext;
 
 import static org.truffleruby.cext.ValueWrapperManager.TAG_MASK;
+import static org.truffleruby.cext.ValueWrapperManager.TRUE_HANDLE;
+import static org.truffleruby.cext.ValueWrapperManager.UNDEF_HANDLE;
 import static org.truffleruby.cext.ValueWrapperManager.LONG_TAG;
+import static org.truffleruby.cext.ValueWrapperManager.NIL_HANDLE;
 import static org.truffleruby.cext.ValueWrapperManager.OBJECT_TAG;
 import static org.truffleruby.cext.ValueWrapperManager.FALSE_HANDLE;
 
+import org.truffleruby.cext.UnwrapNodeGen.NativeToWrapperNodeGen;
 import org.truffleruby.cext.UnwrapNodeGen.ToWrapperNodeGen;
 import org.truffleruby.cext.UnwrapNodeGen.UnwrapNativeNodeGen;
 import org.truffleruby.language.NotProvided;
@@ -82,6 +86,54 @@ public static UnwrapNativeNode create() {
         }
     }
 
+    @ImportStatic(ValueWrapperManager.class)
+    public static abstract class NativeToWrapperNode extends RubyBaseNode {
+
+        public abstract ValueWrapper execute(long handle);
+
+        @Specialization(guards = "handle == FALSE_HANDLE")
+        public ValueWrapper unwrapFalse(long handle) {
+            return new ValueWrapper(false, FALSE_HANDLE);
+        }
+
+        @Specialization(guards = "handle == TRUE_HANDLE")
+        public ValueWrapper unwrapTrue(long handle) {
+            return new ValueWrapper(true, TRUE_HANDLE);
+        }
+
+        @Specialization(guards = "handle == UNDEF_HANDLE")
+        public ValueWrapper unwrapUndef(long handle) {
+            return new ValueWrapper(NotProvided.INSTANCE, UNDEF_HANDLE);
+        }
+
+        @Specialization(guards = "handle == NIL_HANDLE")
+        public ValueWrapper unwrapNil(long handle) {
+            return new ValueWrapper(nil(), NIL_HANDLE);
+        }
+
+        @Specialization(guards = "isTaggedLong(handle)")
+        public ValueWrapper unwrapTaggedLong(long handle) {
+            return new ValueWrapper(handle >> 1, handle);
+        }
+
+        @Specialization(guards = "isTaggedObject(handle)")
+        public ValueWrapper unwrapTaggedObject(long handle) {
+            return getContext().getValueWrapperManager().getWrapperFromHandleMap(handle);
+        }
+
+        public boolean isTaggedLong(long handle) {
+            return (handle & LONG_TAG) == LONG_TAG;
+        }
+
+        public boolean isTaggedObject(long handle) {
+            return handle != FALSE_HANDLE && (handle & TAG_MASK) == OBJECT_TAG;
+        }
+
+        public static NativeToWrapperNode create() {
+            return NativeToWrapperNodeGen.create();
+        }
+    }
+
     @ImportStatic(Message.class)
     public static abstract class ToWrapperNode extends RubyBaseNode {
 
@@ -96,8 +148,7 @@ public ValueWrapper wrappedValueWrapper(ValueWrapper value) {
         public ValueWrapper unwrapTypeCastObject(TruffleObject value,
                 @Cached("IS_POINTER.createNode()") Node isPointerNode,
                 @Cached("AS_POINTER.createNode()") Node asPointerNode,
-                @Cached("create()") UnwrapNativeNode unwrapNativeNode,
-                @Cached("create()") WrapNode wrapNode,
+                @Cached("create()") NativeToWrapperNode nativeToWrapperNode,
                 @Cached("create()") BranchProfile unsupportedProfile,
                 @Cached("create()") BranchProfile nonPointerProfile) {
             if (ForeignAccess.sendIsPointer(isPointerNode, value)) {
@@ -108,12 +159,7 @@ public ValueWrapper unwrapTypeCastObject(TruffleObject value,
                     unsupportedProfile.enter();
                     throw new RaiseException(getContext(), coreExceptions().argumentError(e.getMessage(), this, e));
                 }
-                Object obj = unwrapNativeNode.execute(handle);
-                if (obj != null) {
-                    return wrapNode.execute(obj);
-                } else {
-                    return null;
-                }
+                return nativeToWrapperNode.execute(handle);
             } else {
                 nonPointerProfile.enter();
                 throw new RaiseException(getContext(), coreExceptions().argumentError("Not a handle or a pointer", this));

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

@@ -76,6 +76,19 @@ public synchronized Object getFromHandleMap(long handle) {
         return wrapper.getObject();
     }
 
+    @TruffleBoundary
+    public synchronized ValueWrapper getWrapperFromHandleMap(long handle) {
+        WeakReference<ValueWrapper> ref = handleMap.get(handle);
+        ValueWrapper wrapper;
+        if (ref == null) {
+            return null;
+        }
+        if ((wrapper = ref.get()) == null) {
+            return null;
+        }
+        return wrapper;
+    }
+
     @TruffleBoundary
     public synchronized void removeFromHandleMap(long handle) {
         handleMap.remove(handle);