Change '@' object semantics to ensure values are valid lists

@-objects default value is now a list with an empty object as sole
element. This is way more convenient for LKQL rule files.

Author: HugoGGuerrier

lkql_checker/doc/gnatcheck_rm/using_gnatcheck.rst

@@ -456,9 +456,9 @@ it was provided by the --rule-file option.
 An LKQL rule file can be any valid LKQL file, the only requirement is that it
 must export a ``rules`` top-level symbol. This symbol defines an object value
 containing rules configuration; keys are GNATcheck rules to enable; and values
-are objects containing the rule parameters. A rule parameter value can be of
-the boolean, the integer, the string, or the list of strings type, as shown in
-the simple example below:
+are list of objects, each one representing an instance of the rule with its
+parameters. A rule parameter value can be of the boolean, the integer, the
+string, or the list of strings type, as shown in the simple example below:
 
 ::
 
@@ -467,6 +467,9 @@ the simple example below:
     Forbidden_Attributes: {Forbidden: ["GNAT"], Allowed: ["First", "Last"]}
   }
 
+Using the "@" object notation is strongly advised to make your configuration
+file way more understandable:
+
 Please read the :ref:`Predefined_Rules` documentation to view examples on how
 to provide parameters to rules through LKQL rule files.
 

lkql_jit/cli/src/main/java/com/adacore/lkql_jit/cli/GNATCheckWorker.java

@@ -399,50 +399,19 @@ private static void processInstancesObject(
 
             // Check that the value associated to the rule name is an array like value
             if (args.hasArrayElements()) {
-                // If there is no element in the argument list, just create an instance with no
-                // argument and no alias.
-                if (args.getArraySize() == 0) {
-                    if (toPopulate.containsKey(lowerRuleName)) {
-                        errorInLKQLRuleFile(
-                            lkqlRuleFile,
-                            "Multiple instances with the same name: " + lowerRuleName
-                        );
-                    } else {
-                        toPopulate.put(
-                            lowerRuleName,
-                            new RuleInstance(
-                                lowerRuleName,
-                                Optional.empty(),
-                                sourceMode,
-                                new HashMap<>()
-                            )
-                        );
-                    }
-                }
                 // Else iterate over each argument object and create one instance for each
-                else {
-                    for (long i = 0; i < args.getArraySize(); i++) {
-                        processArgsObject(
-                            lkqlRuleFile,
-                            args.getArrayElement(i),
-                            sourceMode,
-                            lowerRuleName,
-                            toPopulate
-                        );
+                for (long i = 0; i < args.getArraySize(); i++) {
+                    var arg = args.getArrayElement(i);
+                    if (arg.hasMembers()) {
+                        processArgsObject(lkqlRuleFile, arg, sourceMode, lowerRuleName, toPopulate);
+                    } else if (acceptSoleArgs(ruleName) && arg.isString()) {
+                        processSoleArg(arg, sourceMode, ruleName, toPopulate);
+                    } else {
+                        errorInLKQLRuleFile(lkqlRuleFile, "Arguments should be in an object value");
                     }
                 }
-            } else if (args.hasMembers()) {
-                processArgsObject(lkqlRuleFile, args, sourceMode, lowerRuleName, toPopulate);
             } else {
-                // Allow sole arguments for some rules
-                if (acceptSoleArgs(lowerRuleName) && args.isString()) {
-                    processSoleArg(args, sourceMode, lowerRuleName, toPopulate);
-                } else {
-                    errorInLKQLRuleFile(
-                        lkqlRuleFile,
-                        "Rule arguments must be an object or indexable value"
-                    );
-                }
+                errorInLKQLRuleFile(lkqlRuleFile, "The value associated to a rule must be a list");
             }
         }
     }
@@ -455,43 +424,36 @@ private static void processArgsObject(
         final String ruleName,
         final Map<String, RuleInstance> toPopulate
     ) throws LKQLRuleFileError {
-        // Ensure that the given value has members (is an object)
-        if (!argsObject.hasMembers()) {
-            errorInLKQLRuleFile(lkqlRuleFile, "Arguments should be in an object value");
-        }
-        // If this is a valid value, process arguments in it
-        else {
-            // Compute the instance arguments and optional instance name
-            String instanceId = ruleName;
-            Optional<String> instanceName = Optional.empty();
-            Map<String, String> arguments = new HashMap<>();
-            for (String argName : argsObject.getMemberKeys()) {
-                if (argName.equals("instance_name")) {
-                    String aliasName = argsObject.getMember("instance_name").asString();
-                    instanceId = aliasName.toLowerCase();
-                    instanceName = Optional.of(aliasName);
-                } else {
-                    Value argValue = argsObject.getMember(argName);
-                    arguments.put(
-                        argName,
-                        argValue.isString() ? "\"" + argValue + "\"" : argValue.toString()
-                    );
-                }
-            }
-
-            // Add an instance in the instance map if it is not present
-            if (toPopulate.containsKey(instanceId)) {
-                errorInLKQLRuleFile(
-                    lkqlRuleFile,
-                    "Multiple instances with the same name: " + instanceId
-                );
+        // Compute the instance arguments and optional instance name
+        String instanceId = ruleName;
+        Optional<String> instanceName = Optional.empty();
+        Map<String, String> arguments = new HashMap<>();
+        for (String argName : argsObject.getMemberKeys()) {
+            if (argName.equals("instance_name")) {
+                String aliasName = argsObject.getMember("instance_name").asString();
+                instanceId = aliasName.toLowerCase();
+                instanceName = Optional.of(aliasName);
             } else {
-                toPopulate.put(
-                    instanceId,
-                    new RuleInstance(ruleName, instanceName, sourceMode, arguments)
+                Value argValue = argsObject.getMember(argName);
+                arguments.put(
+                    argName,
+                    argValue.isString() ? "\"" + argValue + "\"" : argValue.toString()
                 );
             }
         }
+
+        // Add an instance in the instance map if it is not present
+        if (toPopulate.containsKey(instanceId)) {
+            errorInLKQLRuleFile(
+                lkqlRuleFile,
+                "Multiple instances with the same name: " + instanceId
+            );
+        } else {
+            toPopulate.put(
+                instanceId,
+                new RuleInstance(ruleName, instanceName, sourceMode, arguments)
+            );
+        }
     }
 
     /** Internal function to process a sole string argument for a compiler-based rule. */

lkql_jit/language/src/main/java/com/adacore/lkql_jit/langkit_translator/passes/TranslationPass.java

@@ -31,6 +31,7 @@
 import com.adacore.lkql_jit.nodes.expressions.list_comprehension.ComprehensionAssoc;
 import com.adacore.lkql_jit.nodes.expressions.list_comprehension.ComprehensionAssocList;
 import com.adacore.lkql_jit.nodes.expressions.list_comprehension.ListComprehension;
+import com.adacore.lkql_jit.nodes.expressions.literals.ObjectLiteralFactory.AtObjectValueWrapperNodeGen;
 import com.adacore.lkql_jit.nodes.expressions.literals.*;
 import com.adacore.lkql_jit.nodes.expressions.match.Match;
 import com.adacore.lkql_jit.nodes.expressions.match.MatchArm;
@@ -1336,8 +1337,11 @@ public LKQLNode visit(Liblkqllang.AtObjectLiteral atObjectLiteral) {
             keys.add(key);
             final Liblkqllang.Expr exprBase = assoc.fExpr();
             values[i] = exprBase.isNone()
-                ? new ListLiteral(loc(assoc.fName()), new Expr[0])
-                : (Expr) exprBase.accept(this);
+                ? new ListLiteral(
+                    loc(assoc.fName()),
+                    new Expr[] { new ObjectLiteral(loc(assoc.fName()), new String[0], new Expr[0]) }
+                )
+                : AtObjectValueWrapperNodeGen.create(loc(exprBase), (Expr) exprBase.accept(this));
         }
 
         // Return the new object literal node because at object is juste syntactic sugar

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

@@ -7,6 +7,10 @@
 
 import com.adacore.lkql_jit.nodes.expressions.Expr;
 import com.adacore.lkql_jit.runtime.values.LKQLObject;
+import com.adacore.lkql_jit.runtime.values.lists.LKQLList;
+import com.oracle.truffle.api.dsl.Fallback;
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.object.DynamicObjectLibrary;
@@ -94,4 +98,36 @@ public LKQLObject executeObject(final VirtualFrame frame) {
     public String toString(final int indentLevel) {
         return this.nodeRepresentation(indentLevel);
     }
+
+    // ----- Inner classes -----
+
+    /** Wrapper node ensuring values of "@-objects" are lists. */
+    @NodeChild(value = "wrappedExpr", type = Expr.class)
+    public abstract static class AtObjectValueWrapper extends Expr {
+
+        // ----- Constructors -----
+
+        public AtObjectValueWrapper(SourceSection location) {
+            super(location);
+        }
+
+        // ----- Specializations -----
+
+        @Specialization
+        protected LKQLList onList(LKQLList list) {
+            return list;
+        }
+
+        @Fallback
+        protected LKQLList onOthers(Object obj) {
+            return new LKQLList(new Object[] { obj });
+        }
+
+        // ----- Override methods -----
+
+        @Override
+        public String toString(int indentLevel) {
+            return this.nodeRepresentation(indentLevel);
+        }
+    }
 }

testsuite/tests/gnatcheck_errors/invalid_lkql_rules_config/not_valid_args.lkql

@@ -1,3 +1,3 @@
-val rules = @{
+val rules = {
     identifier_suffixes: "huho"
 }

testsuite/tests/gnatcheck_errors/invalid_lkql_rules_config/test.out

@@ -43,7 +43,7 @@ try "gnatcheck --help" for more information.
 Not valid arguments
 ===================
 
-gnatcheck: error: Rule arguments must be an object or indexable value (not_valid_args.lkql)
+gnatcheck: error: The value associated to a rule must be a list (not_valid_args.lkql)
 gnatcheck: error: no rule to check specified
 try "gnatcheck --help" for more information.
 >>>program returned status code 2

testsuite/tests/interpreter/at_object_literal/script.lkql

@@ -9,3 +9,5 @@ print(x.key1.length)
 print(x.key2)
 print(x.key2.length)
 print(x.key3)
+
+print(x)

testsuite/tests/interpreter/at_object_literal/test.out

@@ -1,5 +1,6 @@
-[]
-0
+[{}]
+1
 [1, 2, 3]
 3
-Coucou
+["Coucou"]
+{"key1": [{}], "key2": [1, 2, 3], "key3": ["Coucou"]}

user_manual/source/language_reference.rst

@@ -503,16 +503,21 @@ An object literal is a literal representation of an object value:
 .. raw:: html
   :file: ../../lkql/build/railroad-diagrams/at_object_lit.svg
 
-"@" preceded object literals are similar to standard object literal with an
-empty list as default value for any key:
+"@" object literals are quite the same as standard objects literals, but each
+associated value is wrapped in a list (if not already one). You are also
+allowed to omit the associated expression when adding a key in the object. The
+default associated value is a list with only one element: an empty object.
 
 .. code-block:: lkql
 
-  # At object literal
-  @{a: 1, b, c: null, d}
+  # @-object literal
+  @{a: "Hello", b, c: 42, d}
 
   # Is similar to
-  {a: 1, b: [], c: null, d: []}
+  {a: ["Hello"], b: [{}], c: [42], d: [{}]}
+
+This "@" object notation are mainly used to express coding standards in LKQL
+rule configuration files, however, you can use it in any context.
 
 Object keys may contain upper-case characters at declaration, but the LKQL
 engine will lower them. This means that object keys are case-insensitive: