Separate handling of legacy rule options from '--rule' options

Firstly, this avoids to emit irrelevant hint messages when only using
the new rule option interface.
Then, for maintaining purpose, splitting those behavior will help us to
remove the old rule options API when the time will come.

Author: HugoGGuerrier

lkql_checker/src/gnatcheck-projects.adb

@@ -1056,7 +1056,7 @@ package body Gnatcheck.Projects is
    -- Process_Rule_Options --
    --------------------------
 
-   type Option_Kind is (File, Legacy_Option);
+   type Option_Kind is (File, Legacy_Option, Single_Rule_Name);
 
    type Option_Record is record
       Kind  : Option_Kind;
@@ -1085,6 +1085,9 @@ package body Gnatcheck.Projects is
             when Legacy_Option =>
                Process_Legacy_Rule_Option
                  (To_String (O.Value), Defined_At => "");
+
+            when Single_Rule_Name =>
+               Process_Single_Rule_Name (To_String (O.Value));
          end case;
       end loop;
       Process_Compiler_Instances;
@@ -1114,11 +1117,16 @@ package body Gnatcheck.Projects is
 
    procedure Add_Rule_By_Name (Rule_Name : String; Prepend : Boolean := False)
    is
-      Lower_Rule : constant String := To_Lower (Rule_Name);
-      Prefix     : constant String :=
-        (if Lower_Rule = "all" then "+" else "+R");
+      use Ada.Strings.Unbounded;
+
+      Opt_Rec : constant Option_Record :=
+        (Single_Rule_Name, To_Unbounded_String (Trim (Rule_Name, Both)));
    begin
-      Add_Legacy_Rule_Option (Prefix & Lower_Rule, Prepend => Prepend);
+      if Prepend then
+         Rule_Options.Prepend (Opt_Rec);
+      else
+         Rule_Options.Append (Opt_Rec);
+      end if;
    end Add_Rule_By_Name;
 
    ------------------------

lkql_checker/src/gnatcheck-rules-rule_table.adb

@@ -104,6 +104,22 @@ package body Gnatcheck.Rules.Rule_Table is
    function Has_Name_Parameter (R : Rident.All_Restrictions) return Boolean;
    --  Tries to guess what kind of parameter the argument restriction has.
 
+   function Check_Rule_Exists
+     (Rule_Name : String; Instantiation_Location : String) return Boolean;
+   --  Check that provided ``Rule`` designates an existing rule, return
+   --  ``True`` in that case. Otherwise, set ``Bad_Rule_Detected`` to
+   --  ``True`` and return ``False``.
+
+   function Check_Instance_Is_Unique
+     (Instance_Name, Instantiation_Location : String) return Boolean;
+   --  Return whether the given instance name isn't already registered in the
+   --  global instance table.
+   --  In case the instance name is already registered this function also sets
+   --  ``Bad_Rule_Detected`` to ``True``, and displays an error message telling
+   --  that the instance cannot be instantiated at ``Instantiation_Location``
+   --  because it has already be registered.
+
+
    procedure Process_Rule_Object
      (LKQL_Rule_File_Name : String;
       Instance_Id         : String;
@@ -330,6 +346,51 @@ package body Gnatcheck.Rules.Rule_Table is
       return Result;
    end Has_Natural_Parameter;
 
+   -----------------------
+   -- Check_Rule_Exists --
+   -----------------------
+
+   function Check_Rule_Exists
+     (Rule_Name : String; Instantiation_Location : String) return Boolean
+   is
+      Rule : constant Rule_Id := Get_Rule (Rule_Name);
+   begin
+      if not Present (Rule) then
+         Error
+           ("unknown rule: "
+            & Rule_Name
+            & ", ignored"
+            & Instantiation_Location);
+         Bad_Rule_Detected := True;
+         return False;
+      end if;
+      return True;
+   end Check_Rule_Exists;
+
+   ------------------------------
+   -- Check_Instance_Is_Unique --
+   ------------------------------
+
+   function Check_Instance_Is_Unique
+     (Instance_Name, Instantiation_Location : String) return Boolean
+   is
+      Instance : constant Rule_Instance_Access := Get_Instance (Instance_Name);
+   begin
+      if Instance /= null then
+         Error
+           ("rule instance with the same name already exists: """
+            & Instance_Name
+            & """ previously instantiated at "
+            & (if Instance.Defined_At /= ""
+               then To_String (Instance.Defined_At)
+               else "command line")
+            & Instantiation_Location);
+         Bad_Rule_Detected := True;
+         return False;
+      end if;
+      return True;
+   end Check_Instance_Is_Unique;
+
    ----------------
    -- Is_Enabled --
    ----------------
@@ -863,6 +924,50 @@ package body Gnatcheck.Rules.Rule_Table is
       end if;
    end Process_LKQL_Rule_File;
 
+   ------------------------------
+   -- Process_Single_Rule_Name --
+   ------------------------------
+
+   procedure Process_Single_Rule_Name (Rule_Name : String) is
+      Lower_Rule_Name : constant String := To_Lower (Rule_Name);
+      Rule            : constant Rule_Id := Get_Rule (Lower_Rule_Name);
+   begin
+      --  Handle cases where the rule is "all"
+      if Lower_Rule_Name = "all" then
+         Turn_All_Rules_On;
+         return;
+      end if;
+
+      --  First, check that the designated rule exists
+      if not Check_Rule_Exists (Lower_Rule_Name, "") then
+         return;
+      end if;
+
+      --  Then, check that the rule isn't already instantiated
+      if not Check_Instance_Is_Unique (Lower_Rule_Name, "") then
+         return;
+      end if;
+
+      --  Finally, check that the designated rule is not a compiler rule
+      if Is_Compiler_Rule (Rule) then
+         Error
+           ("Cannot enable a compiler based rule through the '--rule' CLI "
+            & "option");
+         Bad_Rule_Detected := True;
+         return;
+      end if;
+
+      --  Finally create a new default instance for the rule
+      declare
+         New_Instance : constant Rule_Instance_Access :=
+           All_Rules (Rule).Create_Instance (False);
+      begin
+         New_Instance.Rule := Rule;
+         New_Instance.Source_Mode := General;
+         Turn_Instance_On (New_Instance);
+      end;
+   end Process_Single_Rule_Name;
+
    --------------------------------
    -- Process_Legacy_Rule_Option --
    --------------------------------
@@ -1021,16 +1126,15 @@ package body Gnatcheck.Rules.Rule_Table is
 
          --  We start by getting the instantiated rule identifier, and verify
          --  its existence.
-         Rule := Get_Rule (Option (Word_Start .. Word_End));
-         if not Present (Rule) then
-            Error
-              ("unknown rule: "
-               & Option (Word_Start .. Word_End)
-               & ", ignored"
-               & Diag_Defined_At);
-            Bad_Rule_Detected := True;
-            return;
-         end if;
+         declare
+            R_Name : constant String := Option (Word_Start .. Word_End);
+         begin
+            if Check_Rule_Exists (R_Name, Diag_Defined_At) then
+               Rule := Get_Rule (Option (Word_Start .. Word_End));
+            else
+               return;
+            end if;
+         end;
 
          --  Then we get the instance name, either the user defined one, or
          --  the default: the rule name.
@@ -1044,23 +1148,17 @@ package body Gnatcheck.Rules.Rule_Table is
          --  Check that the option is not instantiating a rule with an already
          --  registered instance name. If the option is trying to disable an
          --  instance, check that this instance exists.
-         if Enable and then Instance /= null then
-            Error
-              ("rule instance with the same name already exists: """
-               & To_String (Instance_Name)
-               & """ previously instantiated at "
-               & (if Instance.Defined_At /= ""
-                  then To_String (Instance.Defined_At)
-                  else "command line")
-               & Diag_Defined_At);
+         if Enable
+           and then not Check_Instance_Is_Unique
+                          (To_String (Instance_Name), Diag_Defined_At)
+         then
             if not Instance_Help_Emitted then
                Info
                  ("if you want to pass multiple parameters to a rule you "
                   & "should use the comma separated notation: e.g. "
                   & "+RMy_Rule:Param1,Param2");
                Instance_Help_Emitted := True;
             end if;
-            Bad_Rule_Detected := True;
             return;
          elsif not Enable and then Instance = null then
             Error

lkql_checker/src/gnatcheck-rules-rule_table.ads

@@ -17,6 +17,11 @@ package Gnatcheck.Rules.Rule_Table is
    function Present (Rule : Rule_Id) return Boolean;
    --  Check if the argument represents an existing rule
 
+   procedure Process_Single_Rule_Name (Rule_Name : String);
+   --  Process the provided rule name by instantiating the corresponding rule
+   --  with its default configuration. If the lowered provided `Rule_Name` is
+   --  "all", then all available rules are enabled.
+
    procedure Process_Legacy_Rule_Option (Option : String; Defined_At : String);
    --  Processes the rule option taken from the command line or from rule file.
    --

testsuite/tests/gnatcheck_errors/same_name_instances/test.out

@@ -11,7 +11,6 @@ In command-line
 ===============
 
 gnatcheck: error: rule instance with the same name already exists: "goto_statements" previously instantiated at command line
-gnatcheck: info: if you want to pass multiple parameters to a rule you should use the comma separated notation: e.g. +RMy_Rule:Param1,Param2
 >>>program returned status code 5
 
 In command-line and rule options