fix: Reference with encoding can accept index access

Author: CatchABus

NativeScript/runtime/Reference.cpp

@@ -336,65 +336,65 @@ Reference::DataPair Reference::GetDataPair(Local<Object> obj) {
     BaseDataWrapper* wrapper = tns::GetValue(isolate, obj);
     tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Reference, isolate);
     ReferenceWrapper* refWrapper = static_cast<ReferenceWrapper*>(wrapper);
-
     BaseDataWrapper* typeWrapper = refWrapper->TypeWrapper();
-    if (typeWrapper == nullptr) {
-        // TODO: Missing type when creating the Reference instance
-        tns::Assert(false, isolate);
-    }
 
     size_t size = 0;
-    const TypeEncoding* typeEncoding = nullptr;
-    bool isUnknownType = false;
-
-    if (Reference::IsSupportedType(typeWrapper->Type())) {
-        switch(typeWrapper->Type()) {
-            case WrapperType::Primitive: {
-                PrimitiveDataWrapper* primitiveWrapper = static_cast<PrimitiveDataWrapper*>(typeWrapper);
-                
-                size = primitiveWrapper->Size();
-                typeEncoding = primitiveWrapper->TypeEncoding();
-                break;
-            }
-            case WrapperType::StructType: {
-                StructTypeWrapper* structTypeWrapper = static_cast<StructTypeWrapper*>(refWrapper->TypeWrapper());
-                StructInfo structInfo = structTypeWrapper->StructInfo();
-                
-                size = structInfo.FFIType()->size;
-                break;
-            }
-            default: {
-                isUnknownType = true;
-                break;
+    
+    if (typeWrapper != nullptr) {
+        const TypeEncoding* typeEncoding = nullptr;
+
+        if (Reference::IsSupportedType(typeWrapper->Type())) {
+            switch(typeWrapper->Type()) {
+                case WrapperType::Primitive: {
+                    PrimitiveDataWrapper* primitiveWrapper = static_cast<PrimitiveDataWrapper*>(typeWrapper);
+                    
+                    size = primitiveWrapper->Size();
+                    typeEncoding = primitiveWrapper->TypeEncoding();
+                    break;
+                }
+                case WrapperType::StructType: {
+                    StructTypeWrapper* structTypeWrapper = static_cast<StructTypeWrapper*>(refWrapper->TypeWrapper());
+                    StructInfo structInfo = structTypeWrapper->StructInfo();
+                    
+                    size = structInfo.FFIType()->size;
+                    break;
+                }
+                default: {
+                    break;
+                }
             }
+        } else {
+            // TODO: Currently only PrimitiveDataWrappers and Structs are supported as type parameters
+            // Objective C class classes should also be handled
+            tns::Assert(false, isolate);
         }
-    } else {
-        isUnknownType = true;
-    }
-    
-    if (isUnknownType) {
-        // TODO: Currently only PrimitiveDataWrappers and Structs are supported as type parameters
-        // Objective C class classes should also be handled
-        tns::Assert(false, isolate);
-    }
 
-    Local<Value> value = refWrapper->Value()->Get(isolate);
-    BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);
-    if (wrappedValue != nullptr && wrappedValue->Type() == WrapperType::Pointer) {
-        PointerWrapper* pw = static_cast<PointerWrapper*>(wrappedValue);
-        void* data = pw->Data();
+        Local<Value> value = refWrapper->Value()->Get(isolate);
+        BaseDataWrapper* wrappedValue = tns::GetValue(isolate, value);
+        if (wrappedValue != nullptr && wrappedValue->Type() == WrapperType::Pointer) {
+            PointerWrapper* pw = static_cast<PointerWrapper*>(wrappedValue);
+            void* data = pw->Data();
 
-        DataPair pair(typeWrapper, typeEncoding, data, size);
-        return pair;
+            DataPair pair(typeWrapper, typeEncoding, data, size);
+            return pair;
+        }
     }
 
     if (refWrapper->Encoding() != nullptr && refWrapper->Data() != nullptr) {
-        DataPair pair(typeWrapper, refWrapper->Encoding(), refWrapper->Data(), size);
+        const TypeEncoding* typeEncoding = refWrapper->Encoding();
+        
+        if (typeWrapper == nullptr) {
+            ffi_type* ffiType = FFICall::GetArgumentType(typeEncoding);
+            size = ffiType->size;
+            FFICall::DisposeFFIType(ffiType, typeEncoding);
+        }
+        
+        DataPair pair(typeWrapper, typeEncoding, refWrapper->Data(), size);
         return pair;
     }
 
     tns::Assert(false, isolate);
-    return DataPair(typeWrapper, nullptr, nullptr, 0);
+    return DataPair(typeWrapper, nullptr, nullptr, size);
 }
 
 bool Reference::IsSupportedType(WrapperType type) {

TestRunner/app/tests/Marshalling/ReferenceTests.js

@@ -412,18 +412,14 @@ describe(module.id, function () {
         }
 
         const pointCollection = TNSPointCollection.alloc().initWithPointsCount(ptr, length);
-        
-        // Runtime converts pointers into references for cases with type so use handleof to get pointer
-        const pointsPtr = interop.handleof(pointCollection.points);
+        const pointsRef = pointCollection.points;
 
         // Check if values were retrieved from pointer
-        const resultRef = new interop.Reference(TNSPoint, pointsPtr);
         for (let i = 0; i < length; i++) {
-            expect(TNSPoint.equals(resultRef[i], structs[i])).toBe(true);
+            expect(TNSPoint.equals(pointsRef[i], structs[i])).toBe(true);
         }
 
         interop.free(ptr);
-        interop.free(pointsPtr);
     });
 
     it("Reference access value from pointer array property", function () {
@@ -441,16 +437,11 @@ describe(module.id, function () {
         }
 
         const pointCollection = TNSPointCollection.alloc().initWithPointsCount(ptr, length);
-        
-        // Runtime converts pointers into references for cases with type so use handleof to get pointer
-        const pointsPtr = interop.handleof(pointCollection.points);
+        const pointsRef = pointCollection.points;
 
-        // Check if values were retrieved from pointer
-        const resultRef = new interop.Reference(TNSPoint, pointsPtr);
-        expect(TNSPoint.equals(resultRef.value, structs[0])).toBe(true);
+        expect(TNSPoint.equals(pointsRef.value, structs[0])).toBe(true);
 
         interop.free(ptr);
-        interop.free(pointsPtr);
     });
 
     it("interops string from CString with fixed length", function () {