fix(interop): Correctly initialize pointers from numbers on 64-bit archs

JavaScript represents 64-bit integers as floating point `double` values.
This means that the conversion from JSValue to pointer is done by
extracting the `double` value and then converting it to integer.

**Caution:** This means that pointers with more than 54 significant bits
are likely to be rounded and misrepresented!
However, current OS and hardware implementations are using 48 bits,
so we're safe at the time being.
See https://en.wikipedia.org/wiki/X86-64#Virtual_address_space_details
and https://en.wikipedia.org/wiki/ARM_architecture#ARMv8-A

Author: mbektchiev

src/NativeScript/Marshalling/Pointer/PointerConstructor.cpp

@@ -33,7 +33,24 @@ void PointerConstructor::finishCreation(VM& vm, PointerPrototype* pointerPrototy
 EncodedJSValue JSC_HOST_CALL PointerConstructor::constructPointerInstance(ExecState* execState) {
     void* value = nullptr;
     if (execState->argumentCount() == 1) {
-        value = reinterpret_cast<void*>(execState->argument(0).toUInt32(execState));
+        auto arg0 = execState->argument(0);
+
+        if (!arg0.isAnyInt()) {
+            auto scope = DECLARE_THROW_SCOPE(execState->vm());
+            return throwVMError(execState, scope, createError(execState, "Pointer constructor's first arg must be an integer."_s));
+        }
+#if __SIZEOF_POINTER__ == 8
+        // JSC stores 64-bit integers as doubles in JSValue.
+        // Caution: This means that pointers with more than 54 significant bits
+        // are likely to be rounded and misrepresented!
+        // However, current OS and hardware implementations are using 48 bits,
+        // so we're safe at the time being.
+        // See https://en.wikipedia.org/wiki/X86-64#Virtual_address_space_details
+        // and https://en.wikipedia.org/wiki/ARM_architecture#ARMv8-A
+        value = reinterpret_cast<void*>(arg0.asAnyInt());
+#else
+        value = reinterpret_cast<void*>(arg0.toInt32(execState));
+#endif
     }
 
     JSValue result = jsCast<GlobalObject*>(execState->lexicalGlobalObject())->interop()->pointerInstanceForPointer(execState, value);

tests/TestRunner/app/Marshalling/TypesTests.js

@@ -1,3 +1,20 @@
+function pointerTo(type, value) {
+    var outerPtr = interop.alloc(interop.sizeof(interop.Pointer));
+    var outerRef = new interop.Reference(type, outerPtr);
+    outerRef.value = value;
+    return outerPtr;
+}
+
+function referenceFromPointerNumber(type, value) {
+    const ptr = new interop.Pointer(value);
+    const ptrToPtr = pointerTo(interop.Pointer, ptr);
+    return new interop.Reference(type, ptrToPtr);
+}
+
+function valueFromPointerNumber(type, value) {
+    return referenceFromPointerNumber(type, value).value;
+}
+
 describe(module.id, function () {
     afterEach(function () {
         TNSClearOutput();
@@ -79,13 +96,6 @@ describe(module.id, function () {
         expect(interop.sizeof(interop.types.selector)).toBe(interop.sizeof(interop.Pointer));
     });
 
-    function pointerTo(type, value) {
-        var outerPtr = interop.alloc(interop.sizeof(interop.Pointer));
-        var outerRef = new interop.Reference(type, outerPtr);
-        outerRef.value = value;
-        return outerPtr;
-    }
-
     it("ReferenceType", function () {
         var ptr = interop.alloc(2 * interop.sizeof(interop.types.id));
         var ref = new interop.Reference(new interop.types.ReferenceType(interop.types.int32), ptr);
@@ -198,4 +208,27 @@ describe(module.id, function () {
         var result = interop.types.double(doublePtr);
         expect(result === number).toBe(true);
     });
+         
+    it("Initialize pointer from non-int throws", function () {
+       expect(() => new interop.Pointer("")).toThrowError(/must be an integer/);
+    });
+
+    it("Initialize reference from pointer", function () {
+       // Create a native NSDictionary holding the pair "value" -> "key"
+       const key = "key";
+       const value = "value";
+       const d1 = NSDictionary.dictionaryWithObjectForKey(value, key);
+       
+       expect(d1.valueForKey(key)).toBe(value, "Dictionary should return initial value string.");
+       
+       // Take the address of the NSDictionary
+       const addr = interop.handleof(d1).toNumber();
+       // Create a new native wrapper using the address
+       const d2 = valueFromPointerNumber(NSDictionary, addr);
+       // Take the address of the new wrapper
+       const addr2 = interop.handleof(d2).toNumber();
+
+       expect(addr2).toBe(addr, "The new object should have the same address.");
+       expect(d2.valueForKey(key)).toEqual(d1.valueForKey(key), "Returned values should be equal");
+    });
 });