Fix segfault on duplicate JSON keys and add tests

Author: lpgauth

native/torque_nif/src/types.rs

@@ -1,4 +1,7 @@
-use rustler::sys::{enif_make_list_from_array, enif_make_map_from_arrays, ERL_NIF_TERM};
+use rustler::sys::{
+    enif_make_list_from_array, enif_make_map_from_arrays, enif_make_map_put, enif_make_new_map,
+    ERL_NIF_TERM,
+};
 use rustler::{Env, NewBinary, Term};
 use sonic_rs::{JsonContainerTrait, JsonType, JsonValueTrait};
 
@@ -83,14 +86,18 @@ pub fn value_to_term<'a>(env: Env<'a>, value: &sonic_rs::Value) -> Term<'a> {
                 }
                 let mut map: ERL_NIF_TERM = 0;
                 unsafe {
-                    enif_make_map_from_arrays(
+                    if enif_make_map_from_arrays(
                         env.as_c_arg(),
                         keys.as_ptr(),
                         vals.as_ptr(),
                         count,
                         &mut map,
-                    );
-                    Term::new(env, map)
+                    ) != 0
+                    {
+                        Term::new(env, map)
+                    } else {
+                        build_map_dedup(env, obj)
+                    }
                 }
             } else {
                 let mut keys: Vec<ERL_NIF_TERM> = Vec::with_capacity(count);
@@ -101,16 +108,38 @@ pub fn value_to_term<'a>(env: Env<'a>, value: &sonic_rs::Value) -> Term<'a> {
                 }
                 let mut map: ERL_NIF_TERM = 0;
                 unsafe {
-                    enif_make_map_from_arrays(
+                    if enif_make_map_from_arrays(
                         env.as_c_arg(),
                         keys.as_ptr(),
                         vals.as_ptr(),
                         count,
                         &mut map,
-                    );
-                    Term::new(env, map)
+                    ) != 0
+                    {
+                        Term::new(env, map)
+                    } else {
+                        build_map_dedup(env, obj)
+                    }
                 }
             }
         }
     }
 }
+
+/// Fallback for objects with duplicate keys. Iterates all pairs so that the
+/// last value for each duplicate key wins, matching common JSON parser behaviour.
+/// Marked `#[cold]` so the optimiser keeps the duplicate-free fast path hot.
+#[cold]
+fn build_map_dedup<'a>(env: Env<'a>, obj: &sonic_rs::Object) -> Term<'a> {
+    unsafe {
+        let mut map = enif_make_new_map(env.as_c_arg());
+        for (k, v) in obj.iter() {
+            let key = make_binary_term(env, k).as_c_arg();
+            let val = value_to_term(env, v).as_c_arg();
+            let mut new_map: ERL_NIF_TERM = 0;
+            enif_make_map_put(env.as_c_arg(), map, key, val, &mut new_map);
+            map = new_map;
+        }
+        Term::new(env, map)
+    }
+}

test/decode_test.exs

@@ -72,6 +72,18 @@ defmodule Torque.DecodeTest do
       assert {:ok, 9_223_372_036_854_775_808} = Torque.decode("9223372036854775808")
     end
 
+    test "duplicate keys - last value wins" do
+      assert {:ok, %{"a" => 2}} = Torque.decode(~s({"a":1,"a":2}))
+    end
+
+    test "duplicate keys in nested object - last value wins" do
+      assert {:ok, %{"x" => %{"a" => 2}}} = Torque.decode(~s({"x":{"a":1,"a":2}}))
+    end
+
+    test "duplicate keys with different value types" do
+      assert {:ok, %{"k" => "str"}} = Torque.decode(~s({"k":1,"k":true,"k":"str"}))
+    end
+
     test "invalid json returns error" do
       assert {:error, _reason} = Torque.decode("{invalid}")
     end

test/torque_test.exs

@@ -231,6 +231,23 @@ defmodule Torque.PointerTest do
     end
   end
 
+  describe "duplicate keys" do
+    test "parse + get on object with duplicate keys - last value wins" do
+      {:ok, doc} = Torque.parse(~s({"a":1,"b":2,"a":3}))
+      assert {:ok, %{"a" => 3, "b" => 2}} = Torque.get(doc, "")
+    end
+
+    test "parse + get nested object with duplicate keys" do
+      {:ok, doc} = Torque.parse(~s({"x":{"k":"first","k":"last"}}))
+      assert {:ok, %{"k" => "last"}} = Torque.get(doc, "/x")
+    end
+
+    test "parse + get_many with duplicate key object" do
+      {:ok, doc} = Torque.parse(~s({"a":1,"a":2}))
+      assert [{:ok, %{"a" => 2}}] = Torque.get_many(doc, [""])
+    end
+  end
+
   describe "parse/1 errors" do
     test "invalid json" do
       assert {:error, _} = Torque.parse("{invalid}")