Adalog: remove the Var_Or_Null type

In practice, logic variables are pointers, and thus are nullable types,
so there is no need for Var_Or_Null, which is an "option" wrapper:
either we have a null Logic_Var (i.e. no variable), either we have a
non-null one.

This is a very minor optimization, as the dependency analysis primitives
now only accept/return a pointer instead of a pointer + a boolean.

TN: SB20-024
For libadalang/langkit#618

Author: pmderodat

support/langkit_support-adalog-solver.adb

@@ -682,12 +682,12 @@ package body Langkit_Support.Adalog.Solver is
       --  if ``Visiting (I) and not Appended (I)``, then we have found a
       --  dependency cycle.
 
-      function Id (S : Var_Or_Null) return Natural
-      is (if S.Exists then Id (S.Logic_Var) else 0);
-      --  Return the Id for the ``S`` variable, or 0 if there is no variable
+      function Id_Or_Null (Var : Logic_Var) return Natural
+      is (if Var = null then 0 else Id (Var));
+      --  Return the Id for the ``Var`` variable, or 0 if there is no variable
 
       function Defined (S : Atomic_Relation_Type) return Natural
-      is (Id (Defined_Var (S)));
+      is (Id_Or_Null (Defined_Var (S)));
       --  Return the Id for the variable that ``S`` defines, or 0 if it
       --  contains no definition.
 
@@ -968,31 +968,31 @@ package body Langkit_Support.Adalog.Solver is
    -- Used_Var --
    --------------
 
-   function Used_Var (Self : Atomic_Relation_Type) return Var_Or_Null
+   function Used_Var (Self : Atomic_Relation_Type) return Logic_Var
    is
       --  We handle Unify here, even though it is not strictly treated in the
       --  dependency graph, so that the Unify_From variable is registered in
       --  the list of variables of the equation. TODO??? Might be cleaner to
       --  have a separate function to return all variables a relation uses?
      (case Self.Kind is
-         when Assign | True | False | N_Predicate => Null_Var,
-         when Propagate => (True, Self.From),
-         when Predicate => (True, Self.Target),
-         when Unify     => (True, Self.Unify_From));
+         when Assign | True | False | N_Predicate => null,
+         when Propagate => Self.From,
+         when Predicate => Self.Target,
+         when Unify     => Self.Unify_From);
 
    -----------------
    -- Defined_Var --
    -----------------
 
-   function Defined_Var (Self : Atomic_Relation_Type) return Var_Or_Null
+   function Defined_Var (Self : Atomic_Relation_Type) return Logic_Var
    is
       --  We handle Unify here, even though it is not strictly treated in the
       --  dependency graph, so that the Target variable is registered in
       --  the list of variables of the equation. TODO??? Might be cleaner to
       --  have a separate function to return all variables a relation defines?
      (case Self.Kind is
-         when Assign | Propagate | Unify             => (True, Self.Target),
-         when Predicate | True | False | N_Predicate => Null_Var);
+         when Assign | Propagate | Unify             => Self.Target,
+         when Predicate | True | False | N_Predicate => null);
 
    -----------------
    -- To_Relation --

support/langkit_support-adalog-solver.ads

@@ -264,11 +264,11 @@ private
    --  Atomic relations dependency graph --
    ----------------------------------------
 
-   --  In this section, we'll define types and operations on the graph of
-   --  dependencies between atomic relations. This is what will allow us to:
+   --  This section defines operations to explore the depenency graph between
+   --  atomic relations. They are used to:
    --
    --  1. Sort a list of atomic relations topologically, so that they form an
-   --     executable list of instructions.
+   --     executable sequence of instructions.
    --
    --  2. Define a map from vars to atomic rels where for every logic variable
    --     ``V``, the map maps ``V -> [R1, R2, R3, ...]`` where
@@ -285,26 +285,15 @@ private
    --  treats both variables as aliases. This dataflow analysis probably
    --  deserves a refactoring to clarify this.
 
-   type Var_Or_Null (Exists : Boolean := False) is record
-      case Exists is
-         when True  => Logic_Var : Logic_Vars.Logic_Var;
-         when False => null;
-      end case;
-   end record;
-   --  Option type for a logic variable. Used to express dependencies from an
-   --  atomic relation to a logic variable.
-
-   Null_Var : constant Var_Or_Null := (Exists => False);
-
-   function Is_Defined_Or_Null (Logic_Var : Var_Or_Null) return Boolean
+   function Is_Defined_Or_Null (Var : Logic_Var) return Boolean
    is
-     ((not Logic_Var.Exists) or else Is_Defined (Logic_Var.Logic_Var));
+     (Var = null or else Is_Defined (Var));
    --  Shortcut predicate. Returns whether a variable is defined or is null
 
-   function Used_Var (Self : Atomic_Relation_Type) return Var_Or_Null;
+   function Used_Var (Self : Atomic_Relation_Type) return Logic_Var;
    --  Return the variable that this atomic relation uses, if there is one
 
-   function Defined_Var (Self : Atomic_Relation_Type) return Var_Or_Null;
+   function Defined_Var (Self : Atomic_Relation_Type) return Logic_Var;
    --  Return the variable that this atomic relation defines, if there is one
 
    -----------------------