feat(ext-core): is_subtype?/is_supertype? now use Graph.get_path_by/2; fix graph building

Author: florius0

lib/apix.schema.extensions/core/type_graph.ex

@@ -22,7 +22,7 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
 
   @doc """
   Runs all the `#{inspect __MODULE__}` functions that are intended to be run
-  after compilation if compilation is finished to avoid corrupting `#{inspect __MODULE__}` state.
+  after compilation is finished to avoid corrupting `#{inspect __MODULE__}` state.
 
   - `prune!/0`
   - `validate!/0`
@@ -157,14 +157,23 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
   - Known and unknown types are not subtypes.
   - `t:Ast.t/0` and `t:Context.t/0` referencing same schema are subtypes.
   """
-  def is_subtype?(subtype, supertype) when (is_struct(subtype, Context) or is_struct(subtype, Ast)) and (is_struct(supertype, Context) or is_struct(supertype, Ast)) do
-    subtype = Apix.Schema.get_schema(subtype) || subtype
-    supertype = Apix.Schema.get_schema(supertype) || supertype
-
-    subtype_vertex = Apix.Schema.hash(subtype)
-    supertype_vertex = Apix.Schema.hash(supertype)
+  def is_subtype?(_subtype, %Context{module: Any, schema: :t, params: []}), do: true
+  def is_subtype?(_subtype, %Ast{module: Any, schema: :t, args: []}), do: true
 
-    !!Graph.edge({subtype_vertex, supertype_vertex, :subtype})
+  def is_subtype?(subtype, supertype) when (is_struct(subtype, Context) or is_struct(subtype, Ast)) and (is_struct(supertype, Context) or is_struct(supertype, Ast)) do
+    subtype =
+      subtype
+      |> Apix.Schema.get_schema()
+      |> Kernel.||(subtype)
+      |> Apix.Schema.hash()
+
+    supertype =
+      supertype
+      |> Apix.Schema.get_schema()
+      |> Kernel.||(supertype)
+      |> Apix.Schema.hash()
+
+    !!Graph.get_path_by(supertype, subtype, &(&1 == :subtype))
   end
 
   @doc """
@@ -174,57 +183,71 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
   - Known and unknown types are not supertypes.
   - `t:Ast.t/0` and `t:Context.t/0` referencing same schema are supertypes.
   """
-  def is_supertype?(supertype, subtype) when (is_struct(supertype, Context) or is_struct(supertype, Ast)) and (is_struct(subtype, Context) or is_struct(subtype, Ast)) do
-    supertype = Apix.Schema.get_schema(supertype) || supertype
-    subtype = Apix.Schema.get_schema(subtype) || subtype
-
-    supertype_vertex = Apix.Schema.hash(supertype)
-    subtype_vertex = Apix.Schema.hash(subtype)
+  def is_supertype?(%Context{module: Any, schema: :t, params: []}, _subtype), do: true
+  def is_supertype?(%Ast{module: Any, schema: :t, args: []}, _subtype), do: true
 
-    !!Graph.edge({supertype_vertex, subtype_vertex, :supertype})
+  def is_supertype?(supertype, subtype) when (is_struct(supertype, Context) or is_struct(supertype, Ast)) and (is_struct(subtype, Context) or is_struct(subtype, Ast)) do
+    supertype =
+      supertype
+      |> Apix.Schema.get_schema()
+      |> Kernel.||(supertype)
+      |> Apix.Schema.hash()
+
+    subtype =
+      subtype
+      |> Apix.Schema.get_schema()
+      |> Kernel.||(subtype)
+      |> Apix.Schema.hash()
+
+    !!Graph.get_path_by(subtype, supertype, &(&1 == :supertype))
   end
 
-  defp build_type_relations!(%Context{} = context) do
-    context.ast
-    |> normalize()
-    |> Ast.prewalk([{context, context}], fn
-      %Ast{module: m, schema: :t, args: [_, _]} = ast, [{parent_ast, parent_ast} | _rest] = acc when m in [And, Or] ->
-        {
-          ast,
-          [{m, ast.args} | acc]
-        }
-
-      %Ast{module: m, schema: :t, args: [_, _]} = ast, [{m, args} | _rest] = acc when m in [And, Or] ->
-        {
-          ast,
-          [{m, ast.args ++ args} | acc]
-        }
+  def build_type_relations!(context_or_ast) do
+    context_or_ast
+    |> case do
+      %Context{} = context ->
+        context.ast
 
-      %Ast{} = ast, [{parent_ast, parent_ast} | _rest] = acc ->
+      %Ast{} = ast ->
+        ast
+    end
+    |> normalize()
+    |> Ast.prewalk({context_or_ast, []}, fn
+      ast, {%Ast{module: And, schema: :t, args: [_, _]} = last, relations} ->
         {
           ast,
-          [{ast, parent_ast} | acc]
+          {last, [{ast, last} | relations]}
         }
 
-      ast, [{Or, args}, {parent_ast, parent_ast} | rest] ->
-        {
-          ast,
-          Enum.map(args, &{parent_ast, &1}) ++ [{parent_ast, parent_ast} | rest]
-        }
+      ast, {%Ast{module: Or, schema: :t, args: [_, _]} = last, relations} ->
+        {ast, {last, [{last, ast} | relations]}}
 
-      ast, [{And, args}, {parent_ast, parent_ast} | rest] ->
-        {
-          ast,
-          Enum.map(args, &{&1, parent_ast}) ++ [{parent_ast, parent_ast} | rest]
-        }
+      ast, {last, []} ->
+        {ast, {ast, [{last, ast}]}}
 
       ast, acc ->
         {ast, acc}
     end)
     |> elem(1)
+    |> elem(1)
     |> Enum.each(fn {sup, sub} ->
-      sup = Apix.Schema.get_schema(sup) || sup
-      sub = Apix.Schema.get_schema(sub) || sub
+      sup =
+        case sup do
+          %{module: m} when m in [And, Or] ->
+            sup
+
+          _ ->
+            Apix.Schema.get_schema(sup) || sup
+        end
+
+      sub =
+        case sub do
+          %{module: m} when m in [And, Or] ->
+            sub
+
+          _ ->
+            Apix.Schema.get_schema(sub) || sub
+        end
 
       sup_vertex = Apix.Schema.hash(sup)
       sub_vertex = Apix.Schema.hash(sub)
@@ -250,31 +273,38 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
   defp normalize_not(%Ast{module: Not, schema: :t, args: [%Ast{module: None, schema: :t, args: []} = ast]}), do: struct(ast, module: Any, schema: :t, args: [])
 
   defp normalize_not(%Ast{module: Not, schema: :t, args: [%Ast{module: And, schema: :t, args: args}]} = ast) do
-    args
-    |> Enum.sort_by(&Apix.Schema.msa/1)
-    |> Enum.map(&struct(ast, module: Not, schema: :t, args: [&1]))
+    args =
+      args
+      |> Enum.sort_by(&Apix.Schema.msa/1)
+      |> Enum.map(&struct(ast, module: Not, schema: :t, args: [&1]))
 
     struct(ast, module: Or, schema: :t, args: args)
   end
 
-  defp normalize_not(%Ast{module: Not, schema: :t, args: [%Ast{module: Or, schema: :t, args: args}]} = ast) do
-    args
-    |> Enum.sort_by(&Apix.Schema.msa/1)
-    |> Enum.map(&struct(ast, module: Not, schema: :t, args: [&1]))
-
-    struct(ast, module: And, schema: :t, args: args)
-  end
-
   defp normalize_not(%Ast{module: Not, schema: :t, args: [arg]} = ast) do
-    reject = [
-      Apix.Schema.msa(arg),
-      {And, :t, 2},
-      {Or, :t, 2},
-      {Not, :t, 1},
-      {Const, :t, 1},
-      {Any, :t, 0},
-      {None, :t, 0}
-    ]
+    reject =
+      arg
+      |> Ast.postwalk([], fn
+        %Ast{module: Or, schema: :t, args: args} = ast, acc ->
+          msa =
+            args
+            |> Enum.map(&Apix.Schema.msa/1)
+            |> Enum.reject(&(&1 == {Or, :t, 2}))
+
+          {ast, msa ++ acc}
+
+        ast, acc ->
+          {ast, acc}
+      end)
+      |> elem(1)
+      |> Kernel.++([
+        {And, :t, 2},
+        {Or, :t, 2},
+        {Not, :t, 1},
+        {Const, :t, 1},
+        {Any, :t, 0},
+        {None, :t, 0}
+      ])
 
     Graph.vertices()
     |> Enum.map(fn hash ->
@@ -284,6 +314,7 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
     end)
     |> Enum.reject(&(Apix.Schema.msa(&1) in reject))
     |> Enum.sort_by(&Apix.Schema.msa/1)
+    |> Enum.uniq()
     |> case do
       [] ->
         struct(ast, module: None, schema: :t, args: [])
@@ -292,8 +323,8 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph do
         context.ast
 
       [first | rest] ->
-        Enum.reduce(rest, first.ast, fn current, acc ->
-          struct(ast, module: And, schema: :t, args: [current.ast, acc])
+        Enum.reduce(rest, %Ast{module: first.module, schema: first.schema, args: Enum.map(first.params, fn _ -> false end)}, fn current, acc ->
+          struct(ast, module: Or, schema: :t, args: [%Ast{module: current.module, schema: current.schema, args: Enum.map(current.params, fn _ -> false end)}, acc])
         end)
     end
   end

lib/apix.schema.extensions/core/type_graph/graph.ex

@@ -95,6 +95,30 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph.Graph do
     end
   end
 
+  @doc """
+  Like `:digraph.get_path/3`, but only traverses edges for which `predicate` returns `true`.
+
+  `predicate` can have arity 1, 3, or 4:
+    - `fn label -> boolean end`
+    - `fn from, to` -> boolean end`
+    - `fn from, to, label -> boolean end`
+    - `fn edge, from, to, label -> boolean end`
+
+  Returns `false` if no path exists, or a list of vertices `[v1, ..., vn]` otherwise.
+  """
+  @spec get_path_by(
+          :digraph.vertex(),
+          :digraph.vertex(),
+          (:digraph.label() -> boolean())
+          | (:digraph.vertex(), :digraph.vertex() -> boolean())
+          | (:digraph.vertex(), :digraph.vertex(), :digraph.label() -> boolean())
+          | (:digraph.edge(), :digraph.vertex(), :digraph.vertex(), :digraph.label() -> boolean())
+        ) :: false | [:digraph.edge()]
+  def get_path_by(source, target, predicate) when is_function(predicate, 1) or is_function(predicate, 2) or is_function(predicate, 3) or is_function(predicate, 4) do
+    ensure!()
+    GenServer.call(__MODULE__, {:get_path_by, source, target, predicate})
+  end
+
   # GenServer
 
   @impl GenServer
@@ -150,6 +174,11 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph.Graph do
     {:reply, reply, state}
   end
 
+  def handle_call({:get_path_by, source, target, predicate}, _from, state) do
+    path = do_get_path_by(state.digraph, source, target, predicate)
+    {:reply, path, state}
+  end
+
   @impl GenServer
   def handle_info({:EXIT, _from, _reason}, state) do
     {:ok, state} = do_dump(state)
@@ -213,4 +242,68 @@ defmodule Apix.Schema.Extensions.Core.TypeGraph.Graph do
 
     {:ok, %__MODULE__{digraph: digraph}}
   end
+
+  defp do_get_path_by(_g, v, v, _predicate), do: [v]
+
+  defp do_get_path_by(g, source, target, predicate) do
+    # Ensure both vertices exist (match :digraph.get_path/3 behavior)
+    with {^source, _} <- :digraph.vertex(g, source) || :error,
+         {^target, _} <- :digraph.vertex(g, target) || :error do
+      bfs_with_edge_filter(g, source, target, predicate)
+    else
+      _ -> false
+    end
+  end
+
+  defp bfs_with_edge_filter(g, source, target, predicate) do
+    # Standard BFS over vertices, but we only traverse out-edges passing `predicate`
+    queue = :queue.from_list([source])
+    visited = MapSet.new([source])
+    prev = %{source => nil}
+
+    do_bfs(g, target, predicate, queue, visited, prev)
+  end
+
+  defp do_bfs(g, target, predicate, queue, visited, prev) do
+    case :queue.out(queue) do
+      {:empty, _} ->
+        false
+
+      {{:value, v}, queue1} ->
+        if v == target do
+          reconstruct_path(prev, v)
+        else
+          {queue2, visited2, prev2} = expand_neighbours(g, v, predicate, queue1, visited, prev)
+          do_bfs(g, target, predicate, queue2, visited2, prev2)
+        end
+    end
+  end
+
+  defp expand_neighbours(g, v, predicate, queue, visited, prev) do
+    # Filter out-edges by predicate, then enqueue unseen `to` vertices
+    Enum.reduce(:digraph.out_edges(g, v), {queue, visited, prev}, fn e, {q, vis, pr} ->
+      {^e, from, to, label} = :digraph.edge(g, e)
+
+      if edge_passes?(predicate, e, from, to, label) and not MapSet.member?(vis, to) do
+        {:queue.in(to, q), MapSet.put(vis, to), Map.put(pr, to, from)}
+      else
+        {q, vis, pr}
+      end
+    end)
+  end
+
+  defp edge_passes?(predicate, _e, _from, _to, label) when is_function(predicate, 1), do: predicate.(label)
+  defp edge_passes?(predicate, _e, from, to, _label) when is_function(predicate, 2), do: predicate.(from, to)
+  defp edge_passes?(predicate, _e, from, to, label) when is_function(predicate, 3), do: predicate.(from, to, label)
+  defp edge_passes?(predicate, e, from, to, label) when is_function(predicate, 4), do: predicate.(e, from, to, label)
+
+  defp reconstruct_path(prev, v), do: do_reconstruct(prev, v, []) |> Enum.reverse()
+
+  defp do_reconstruct(prev, v, acc) do
+    case Map.fetch(prev, v) do
+      {:ok, nil} -> [v | acc]
+      {:ok, p} -> do_reconstruct(prev, p, [v | acc])
+      :error -> false
+    end
+  end
 end