Remove the object concatenation support

Author: HugoGGuerrier

lkql_checker/doc/gnatcheck_rm/using_gnatcheck.rst

@@ -592,8 +592,8 @@ the following configuration will raise an error:
 
 You cannot provide more than **one** LKQL rule file when running GNATcheck. In
 order to compose a rule file with another you have to use the
-:ref:`LKQL importation mechanism<module_importation>` and concatenate rule
-objects. Here is an example of LKQL rule file composition:
+:ref:`LKQL importation mechanism<module_importation>` and combine rule objects.
+Here is an example of LKQL rule file composition:
 
 .. code-block:: lkql
 
@@ -609,9 +609,9 @@ objects. Here is an example of LKQL rule file composition:
 
   import common_rules
 
-  val rules = common_rules.rules & @{
-    Redundant_Null_Statements
-  }
+  val rules = common_rules.rules.combine(
+    @{ Redundant_Null_Statements }
+  )
 
 Then you can run GNATcheck with the ``specific_rules.lkql`` file as coding
 standard to perform rules defined in ``common_rules.lkql`` combined to the ones
@@ -641,9 +641,12 @@ invalid:
 
   import common_rules
 
-  val rules = common_rules.rules & @{
-    Forbidden_Attributes: {Forbidden: ["Last"], instance_name: "Forbid_Attr"}
-  }
+  val rules = common_rules.rules.combine(@{
+    Forbidden_Attributes: {
+      Forbidden: ["Last"],
+      instance_name: "Forbid_Attr"
+    }
+  })
   # error: This rule configuration defines two instances with the same name: "Forbid_Attr"
 
 

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

@@ -7,17 +7,12 @@
 
 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 {
 
@@ -43,48 +38,6 @@ 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(

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/ambiguous_import.lkql

@@ -1,5 +1,5 @@
 import null_stmt
 
-val rules = null_stmt.rules & @{
-    Goto_Statements
-}
+val rules = null_stmt.rules.combine(
+    @{ Goto_Statements }
+)

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/circular_import.lkql

@@ -1,5 +1,5 @@
 import part_one
 
-val rules = part_one.rules & @{
-    Goto_Statements
-}
+val rules = part_one.rules.combine(
+    @{ Goto_Statements }
+)

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/invalid_import.lkql

@@ -1,3 +1,3 @@
 import null_stmt
 
-val rules = null_stmt.rules @{}
+val rules = null_stmt.rules.combine(@{})

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/other_rule_configs/null_stmt.lkql

@@ -0,0 +1,3 @@
+val rules = @{
+    Redundant_Null_Statements
+}

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/other_rule_configs/part_one.lkql

@@ -1,5 +1,5 @@
 import part_two
 
-val rules = part_two.rules & @{
-    Redundant_Null_Statements
-}
+val rules = part_two.rules.combine(
+    @{ Redundant_Null_Statements }
+)

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/other_rule_configs/part_two.lkql

@@ -1,5 +1,5 @@
 import part_one
 
-val rules = part_one.rules & @{
-    Blocks
-}
+val rules = part_one.rules.combine(
+    @{ Blocks }
+)

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/with_overlapping.lkql

@@ -1,5 +1,5 @@
 import uncond_goto_stmt
 
-val rules = uncond_goto_stmt.rules & @{
-    Goto_Statements
-}
+val rules = uncond_goto_stmt.rules.combine(
+    @{ Goto_Statements }
+)

testsuite/tests/gnatcheck/lkql_rules_config/combine_rule_files/without_overlapping.lkql

@@ -1,5 +1,5 @@
 import null_stmt
 
-val rules = null_stmt.rules & @{
-    Goto_Statements
-}
+val rules = null_stmt.rules.combine(
+    @{ Goto_Statements }
+)