Implement object concatenation in LKQL

Author: HugoGGuerrier

lkql_jit/language/src/main/java/com/adacore/lkql_jit/nodes/expressions/literals/ObjectLiteral.java

@@ -52,7 +52,7 @@ public final class ObjectLiteral extends Expr {
     public ObjectLiteral(final SourceSection location, final String[] keys, final Expr[] values) {
         super(location);
         this.keys = keys;
-        this.shape = Shape.newBuilder().build();
+        this.shape = LKQLObject.emptyShape();
         this.values = values;
         this.objectLibrary = DynamicObjectLibrary.getUncached();
     }

lkql_jit/language/src/main/java/com/adacore/lkql_jit/nodes/utils/ConcatenationNode.java

@@ -7,12 +7,17 @@
 
 import com.adacore.lkql_jit.exception.LKQLRuntimeException;
 import com.adacore.lkql_jit.nodes.LKQLNode;
+import com.adacore.lkql_jit.runtime.values.LKQLObject;
 import com.adacore.lkql_jit.runtime.values.lists.LKQLList;
+import com.adacore.lkql_jit.utils.Constants;
 import com.adacore.lkql_jit.utils.LKQLTypesHelper;
 import com.adacore.lkql_jit.utils.functions.StringUtils;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.object.DynamicObjectLibrary;
 
 public abstract class ConcatenationNode extends Node {
 
@@ -38,6 +43,48 @@ protected LKQLList doLists(LKQLList left, LKQLList right, LKQLNode caller) {
         return new LKQLList(resContent);
     }
 
+    @Specialization(limit = Constants.SPECIALIZED_LIB_LIMIT)
+    protected LKQLObject doObjects(
+        LKQLObject left,
+        LKQLObject right,
+        LKQLNode caller,
+        @CachedLibrary("left") DynamicObjectLibrary leftLib,
+        @CachedLibrary("right") DynamicObjectLibrary rightLib,
+        @CachedLibrary(limit = Constants.DISPATCHED_LIB_LIMIT) DynamicObjectLibrary resLib,
+        @Cached ConcatenationNode innerConcat
+    ) {
+        // Create the result object
+        LKQLObject res = new LKQLObject(LKQLObject.emptyShape());
+
+        // Insert all keys of the left object in the result, resolving conflicts by merging
+        // values.
+        for (var key : leftLib.getKeyArray(left)) {
+            if (!rightLib.containsKey(right, key)) {
+                resLib.put(res, key, leftLib.getOrDefault(left, key, null));
+            } else {
+                resLib.put(
+                    res,
+                    key,
+                    innerConcat.execute(
+                        leftLib.getOrDefault(left, key, null),
+                        rightLib.getOrDefault(right, key, null),
+                        caller
+                    )
+                );
+            }
+        }
+
+        // Insert keys from the right object that aren't in the resulting object
+        for (var key : rightLib.getKeyArray(right)) {
+            if (!resLib.containsKey(res, key)) {
+                resLib.put(res, key, rightLib.getOrDefault(right, key, null));
+            }
+        }
+
+        // Return the resulting object
+        return res;
+    }
+
     @Fallback
     protected void nonConcatenable(Object left, Object right, LKQLNode caller) {
         throw LKQLRuntimeException.unsupportedOperation(

lkql_jit/language/src/main/java/com/adacore/lkql_jit/runtime/values/LKQLObject.java

@@ -24,6 +24,10 @@
 @ExportLibrary(InteropLibrary.class)
 public final class LKQLObject extends ObjectLKQLValue implements LKQLValue {
 
+    // ----- Attributes -----*
+
+    private static final Shape.Builder shapeBuilder = Shape.newBuilder();
+
     // ----- Constructors -----
 
     /** Create a new LKQL object with its dynamic shape. */
@@ -38,13 +42,19 @@ public LKQLObject(final Shape shape) {
      * library so this is not designed for performance critical usages.
      */
     public static LKQLObject createUncached(final Object[] keys, final Object[] values) {
-        final LKQLObject res = new LKQLObject(Shape.newBuilder().build());
+        final LKQLObject res = new LKQLObject(emptyShape());
         for (int i = 0; i < keys.length; i++) {
             uncachedObjectLibrary.put(res, keys[i], values[i]);
         }
         return res;
     }
 
+    /** Get an empty dynamic shape. */
+    @CompilerDirectives.TruffleBoundary
+    public static Shape emptyShape() {
+        return shapeBuilder.build();
+    }
+
     // ----- Value methods -----
 
     /** Exported message to compare two LKQL objects. */

testsuite/tests/interpreter/object_concat/script.lkql

@@ -0,0 +1,5 @@
+print({a: 1} & {b: 2})
+print({a: "A"} & {a: "B"})
+print({a: [1, 2], b: "hello"} & {a: [3, 4], c: "world"})
+print(concat([{a: 1}, {b: 2}, {c: 3}]))
+print({a: 1} & {a: 2})

testsuite/tests/interpreter/object_concat/test.out

@@ -0,0 +1,7 @@
+{"a": 1, "b": 2}
+{"a": "AB"}
+{"a": [1, 2, 3, 4], "b": "hello", "c": "world"}
+{"a": 1, "b": 2, "c": 3}
+script.lkql:5:7: error: Unsupported operation: Int & Int
+5 | print({a: 1} & {a: 2})
+  |       ^^^^^^^^^^^^^^^

testsuite/tests/interpreter/object_concat/test.yaml

@@ -0,0 +1,2 @@
+driver: 'interpreter'
+project: 'default_project/default.gpr'

user_manual/source/language_reference.rst

@@ -113,7 +113,8 @@ Composite Data Types
 
 ``Object``
   Objects are heterogeneous records that can contain any number of key to value
-  mappings, where keys are labels and values are any valid LKQL value.
+  mappings, where keys are labels and values are any valid LKQL value. Objects
+  support concatenation.
 
 
 
@@ -740,16 +741,35 @@ LKQL has a few built-in operators available:
 
   true and false or (a == b) and (not c)
 
-- String and list concatenation
+- Value concatenation
 
 .. code-block:: lkql
 
+  # Strings concatenation
   "Hello " & name
 
 .. code-block:: lkql
 
+  # Lists concatenation
   [1, 2, 3] & [4, 5, 6]
 
+.. code-block:: lkql
+
+  # Objects concatenation
+  {a: 1} & {b: 2}
+
+.. note::
+
+  When concatenation object values, keys are combined in the result. In case of
+  conflicting keys, their values are recursively concatenated, as it is shown
+  in the following example:
+
+  .. code-block:: lkql
+
+    {a: 1} & {b: 2}           # Result: {a: 1, b: 2}
+    {a: [1, 2]} & {a: [3, 4]} # Result: {a: [1, 2, 3, 4]}
+    {a: 1} & {a: 2}           # Runtime error! Impossible to concatenate `Int`s
+
 
 Module Importation
 ^^^^^^^^^^^^^^^^^^