Deep copy improvements

src/DynamicObj/FableJS.fs

@@ -168,4 +168,11 @@ module FableJS =
         let cloneICloneable (o:obj) : obj =
             jsNative
 
+    module Dictionaries =
+        [<Emit("""$0 instanceof Map""")>]
+        let isMap (o:obj) : bool =
+            jsNative
+        [<Emit("""$0 instanceof Dictionary""")>]
+        let isDict (o:obj) : bool =
+            jsNative
 #endif

src/DynamicObj/FablePy.fs

@@ -220,4 +220,10 @@ module FablePy =
         [<Emit("""$0.System_ICloneable_Clone()""")>]
         let cloneICloneable (o:obj) : obj =
             nativeOnly
+
+    module Dictionaries =
+        [<Emit("""isinstance($0, dict)""")>]
+        let isDict (o:obj) : bool =
+            nativeOnly
+
 #endif

src/DynamicObj/Playground.fsx

@@ -13,18 +13,10 @@
 open Fable.Pyxpecto
 open DynamicObj
 
-type T(dyn:string, stat:string) as this=
-    inherit DynamicObj()
+let r1 = ResizeArray([1; 2])
+let r2 = ResizeArray([1; 2])
+let r3 = r1
 
-    do 
-        this.SetProperty("Dyn", dyn)
-
-    member this.Stat = stat
-
-let first = T("dyn1", "stat1")
-let second = T("dyn2", "stat2")
-
-let _ = second.ShallowCopyDynamicPropertiesTo(first)
-
-first |> DynObj.print
-second |> DynObj.print
+printfn "%A" (LanguagePrimitives.PhysicalEquality r1 r2)
+printfn "%A" (LanguagePrimitives.PhysicalEquality r2 r2)
+printfn "%A" (LanguagePrimitives.PhysicalEquality r3 r1)

tests/CSharpTests/CSharpTests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/DynamicObj.fs

@@ -0,0 +1,2 @@
+module DeepCopyDynamicObj
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/DynamicObjCollections.fs

@@ -0,0 +1,2 @@
+module DeepCopyDynamicObjCollections
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/ICloneable.fs

@@ -0,0 +1,2 @@
+module DeepCopyICloneable
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/Main.fs

@@ -0,0 +1,13 @@
+module CopyUtils.Tests
+
+open System
+open Fable.Pyxpecto
+open DynamicObj
+open Fable.Core
+
+let main = testList "CopyUtils.tryDeepCopyObj" [
+    DeepCopyPrimitives.tests_DeepCopyPrimitives
+    DeepCopyResizeArrays.tests_DeepCopyResizeArrays
+    DeepCopyDictionaries.tests_DeepCopyDictionaries
+]
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/Primitives.fs

@@ -0,0 +1,60 @@
+module DeepCopyPrimitives
+
+open System
+open Fable.Pyxpecto
+open DynamicObj
+open Fable.Core
+open TestUtils
+
+let tests_DeepCopyPrimitives = testList "Primitives" [
+    testCase "bool" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj true
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "byte" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1uy
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "sbyte" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1y
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "int16" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1s
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "uint16" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1us
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "int" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "uint" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1u
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "int64" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1L
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "uint64" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1uL
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    #if !FABLE_COMPILER
+    testCase "nativeint" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj (System.IntPtr(1))
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "unativeint" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj (System.UIntPtr(1u))
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    #endif
+    testCase "float" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1.0
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "float32" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 1.0f
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "char" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj 'A'
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "string" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj "Hi"
+        Expect.equal copy original "Expected values of copy and original to be equal"
+    testCase "unit" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj ()
+        Expect.equal copy original "Expected values of copy and original to be equal"
+]

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/ResizeArrays.fs

@@ -0,0 +1,148 @@
+module DeepCopyResizeArrays
+
+open System
+open Fable.Pyxpecto
+open DynamicObj
+open Fable.Core
+open TestUtils
+
+let tests_DeepCopyResizeArrays = testList "ResizeArrays" [
+    testCase "bool" <| fun _ -> 
+        let arr = ResizeArray([true; false])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- false
+        Expect.sequenceEqual original (ResizeArray([false; false])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([true; false])) "Clone should not be affected by original mutation"
+    testCase "byte" <| fun _ -> 
+        let arr = ResizeArray([1uy; 2uy])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2uy
+        Expect.sequenceEqual original (ResizeArray([2uy; 2uy])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1uy; 2uy])) "Clone should not be affected by original mutation"
+    testCase "sbyte" <| fun _ -> 
+        let arr = ResizeArray([1y; 2y])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2y
+        Expect.sequenceEqual original (ResizeArray([2y; 2y])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1y; 2y])) "Clone should not be affected by original mutation"
+    testCase "int16" <| fun _ -> 
+        let arr = ResizeArray([1s; 2s])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2s
+        Expect.sequenceEqual original (ResizeArray([2s; 2s])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1s; 2s])) "Clone should not be affected by original mutation"
+    testCase "uint16" <| fun _ ->
+        let arr = ResizeArray([1us; 2us])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2us
+        Expect.sequenceEqual original (ResizeArray([2us; 2us])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1us; 2us])) "Clone should not be affected by original mutation"
+    testCase "int" <| fun _ -> 
+        let arr = ResizeArray([1; 2])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2
+        Expect.sequenceEqual original (ResizeArray([2; 2])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1; 2])) "Clone should not be affected by original mutation"
+    testCase "uint" <| fun _ -> 
+        let arr = ResizeArray([1u; 2u])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2u
+        Expect.sequenceEqual original (ResizeArray([2u; 2u])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1u; 2u])) "Clone should not be affected by original mutation"
+    testCase "int64" <| fun _ -> 
+        let arr = ResizeArray([1L; 2L])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2L
+        Expect.sequenceEqual original (ResizeArray([2L; 2L])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1L; 2L])) "Clone should not be affected by original mutation"
+    testCase "uint64" <| fun _ -> 
+        let arr = ResizeArray([1uL; 2uL])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2uL
+        Expect.sequenceEqual original (ResizeArray([2uL; 2uL])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1uL; 2uL])) "Clone should not be affected by original mutation"
+    testCase "float" <| fun _ -> 
+        let arr = ResizeArray([1.0; 2.0])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2.0
+        Expect.sequenceEqual original (ResizeArray([2.0; 2.0])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1.0; 2.0])) "Clone should not be affected by original mutation"
+    testCase "float32" <| fun _ -> 
+        let arr = ResizeArray([1.0f; 2.0f])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2.0f
+        Expect.sequenceEqual original (ResizeArray([2.0f; 2.0f])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1.0f; 2.0f])) "Clone should not be affected by original mutation"
+    testCase "char" <| fun _ -> 
+        let arr = ResizeArray(['A'; 'B'])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 'B'
+        Expect.sequenceEqual original (ResizeArray(['B'; 'B'])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray(['A'; 'B'])) "Clone should not be affected by original mutation"
+    testCase "string" <| fun _ -> 
+        let arr = ResizeArray(["Hi"; "Bye"])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- "Bye"
+        Expect.sequenceEqual original (ResizeArray(["Bye"; "Bye"])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray(["Hi"; "Bye"])) "Clone should not be affected by original mutation"
+    testCase "unit" <| fun _ -> 
+        let arr = ResizeArray([(); ()])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        // transpilation fun
+        let arr2 = ResizeArray([()])
+        arr.Add(arr2[0])
+        Expect.sequenceEqual original (ResizeArray([(); (); ()])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([(); ()])) "Clone should not be affected by original mutation"
+
+    // some cases are not transpilable
+
+    #if !FABLE_COMPILER_PYTHON
+    testCase "decimal" <| fun _ -> 
+        let arr = ResizeArray([1.0M; 2.0M])
+        let original, copy = constructDeepCopiedObj arr
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+        arr[0] <- 2.0M
+        Expect.sequenceEqual original (ResizeArray([2.0M; 2.0M])) "Original schould have been mutated"
+        Expect.sequenceEqual copy (ResizeArray([1.0M; 2.0M])) "Clone should not be affected by original mutation"
+    #endif
+
+    #if !FABLE_COMPILER
+    testCase "nativeint" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj (ResizeArray([System.IntPtr(1); System.IntPtr(2)]))
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+    testCase "unativeint" <| fun _ -> 
+        let original, copy = constructDeepCopiedObj (ResizeArray([System.UIntPtr(1u); System.UIntPtr(2u)]))
+        Expect.sequenceEqual copy original "Expected values of copy and original to be equal"
+        Expect.notReferenceEqual copy original "Expected values of copy and original to be not reference equal"
+    #endif
+]

tests/DynamicObject.Tests/DynamicObject.Tests.fsproj

@@ -9,6 +9,13 @@
 
   <ItemGroup>
     <Compile Include="TestUtils.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\Primitives.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\ResizeArrays.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\Dictionaries.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\DynamicObjCollections.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\ICloneable.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\DynamicObj.fs" />
+    <Compile Include="CopyUtils.tryDeepCopyObj\Main.fs" />
     <Compile Include="DynamicObj\RemoveProperty.fs" />
     <Compile Include="DynamicObj\SetProperty.fs" />
     <Compile Include="DynamicObj\GetHashcode.fs" />

tests/DynamicObject.Tests/Main.fs

@@ -4,6 +4,7 @@ open Fable.Pyxpecto
 
 let all = testSequenced <| testList "DynamicObj" [
     ReflectionUtils.Tests.main
+    CopyUtils.Tests.main
     DynamicObj.Tests.main
     DynObj.Tests.main
     Inheritance.Tests.main

tests/DynamicObject.Tests/TestUtils.fs

@@ -33,8 +33,11 @@ let constructDeepCopiedClone<'T> (props: seq<string*obj>) =
     let original = DynamicObj()
     props
     |> Seq.iter (fun (propertyName, propertyValue) -> original.SetProperty(propertyName, propertyValue))
-    let clone = original.DeepCopyProperties()
-    original, clone |> unbox<'T>
+    let clone : 'T = original.DeepCopyProperties() |> unbox<'T>
+    original, clone 
+
+let constructDeepCopiedObj<'T> (original: 'T) =
+    original, (CopyUtils.tryDeepCopyObj original |> unbox<'T>)
 
 let bulkMutate (props: seq<string*obj>) (dyn: #DynamicObj) =
     props |> Seq.iter (fun (propertyName, propertyValue) -> dyn.SetProperty(propertyName, propertyValue))
@@ -56,6 +59,13 @@ module DynObj =
             | _ -> failwith "Empty property list"
         getProp dyn props
 
+#if FABLE_COMPILER_PYTHON
+module Py =
+    [<Emit("$0 is $1")>]
+    let isReferenceEqual o1 o2 : bool =
+        nativeOnly
+#endif
+
 module Expect =
     /// Expects the `actual` sequence to equal the `expected` one.
     let sequenceEqual actual expected message =
@@ -71,6 +81,22 @@ module Expect =
         failwithf "%s. Sequence actual longer than expected, at pos %i found item %O."
           message i a
 
+
+
     let referenceEqual actual expected message =
+        #if FABLE_COMPILER_PYTHON
+        if not (Py.isReferenceEqual actual expected) then
+            failwith message
+        #else
         if not (LanguagePrimitives.PhysicalEquality actual expected) then
-            failwith message
+            failwith message
+        #endif
+
+    let notReferenceEqual actual expected message =
+        #if FABLE_COMPILER_PYTHON
+        if (Py.isReferenceEqual actual expected) then
+            failwith message
+        #else
+        if (LanguagePrimitives.PhysicalEquality actual expected) then
+            failwith message
+        #endif