Hide functions after @doc false or @impl true

Author: jiegillet

lib/elixir_analyzer/exercise_test/common_checks/private_helper_functions.ex

@@ -12,10 +12,11 @@ defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.PrivateHelperFunctions do
   def run(_ast, nil), do: []
 
   def run(code_ast, exemploid_ast) do
-    {_, code_definitions} = Macro.prewalk(code_ast, [], &traverse/2)
-    {_, exemploid_definitions} = Macro.prewalk(exemploid_ast, [], &traverse/2)
+    {_, code_hidden} = Macro.prewalk(code_ast, [], &find_hidden/2)
+    {_, code_def} = Macro.prewalk(code_ast, [], &traverse/2)
+    {_, exemploid_def} = Macro.prewalk(exemploid_ast, [], &traverse/2)
 
-    case Enum.reverse(find_public_helpers(code_definitions, exemploid_definitions)) do
+    case find_public_helpers(code_def, code_hidden, exemploid_def) |> Enum.reverse() do
       [] ->
         []
 
@@ -35,23 +36,55 @@ defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.PrivateHelperFunctions do
     end
   end
 
-  defp traverse({op, _meta, [{:when, _, [{name, _, args} | _]} | _]} = ast, names)
+  defp find_hidden({_, _, args} = ast, names) when is_list(args) do
+    {ast, do_find_hidden(args, names)}
+  end
+
+  defp find_hidden(ast, names), do: {ast, names}
+
+  defp do_find_hidden([doc, function | rest], names) do
+    hidden? =
+      match?({:@, _, [{:doc, _, [false]}]}, doc) or match?({:@, _, [{:impl, _, [true]}]}, doc)
+
+    def? = function_def?(function)
+
+    if hidden? and def? do
+      names = [get_function_data(function) | names]
+      do_find_hidden(rest, names)
+    else
+      do_find_hidden([function | rest], names)
+    end
+  end
+
+  defp do_find_hidden(_, names), do: names
+
+  defp function_def?({_op, _, [{:when, _, [{_name, _, _args} | _]} | _]}), do: true
+  defp function_def?({_op, _, [{_name, _, _args} | _]}), do: true
+  defp function_def?(_node), do: false
+
+  defp get_function_data({op, _, [{:when, _, [{name, _, args} | _]} | _]}) do
+    {op, name, if(is_atom(args), do: 0, else: length(args))}
+  end
+
+  defp get_function_data({op, _, [{name, _, args} | _]}) do
+    {op, name, if(is_atom(args), do: 0, else: length(args))}
+  end
+
+  defp traverse({op, _, [{:when, _, [{name, _, args} | _]} | _]} = ast, names)
        when op in @public_ops do
     definition = {op, name, if(is_atom(args), do: 0, else: length(args))}
     {ast, [definition | names]}
   end
 
-  defp traverse({op, _meta, [{name, _, args} | _]} = ast, names) when op in @public_ops do
+  defp traverse({op, _, [{name, _, args} | _]} = ast, names) when op in @public_ops do
     definition = {op, name, if(is_atom(args), do: 0, else: length(args))}
     {ast, [definition | names]}
   end
 
-  defp traverse(ast, names) do
-    {ast, names}
-  end
+  defp traverse(ast, names), do: {ast, names}
 
-  defp find_public_helpers(code_definitions, exemploid_definitions) do
-    (Enum.uniq(code_definitions) -- exemploid_definitions)
+  defp find_public_helpers(code_def, code_hidden, exemploid_def) do
+    ((Enum.uniq(code_def) -- exemploid_def) -- code_hidden)
     |> Enum.map(&print_definition/1)
   end
 

test/elixir_analyzer/exercise_test/common_checks/private_helper_functions_test.exs

@@ -204,6 +204,56 @@ defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.PrivateHelperFunctionsTest do
 
       assert PrivateHelperFunctions.run(code, @pacman_exemplar) == [{:fail, comment}]
     end
+
+    test "@doc false hides the function" do
+      code =
+        quote do
+          defmodule Rules do
+            defmodule BooleanLogic do
+              @doc false
+              def do_or(left, right), do: left or right
+
+              @doc false
+              def do_and(left, right) when is_boolean(left), do: left and right
+            end
+
+            def score?(touching_power_pellet, touching_dot) do
+              BooleanLogic.do_or(touching_power_pellet, touching_dot)
+            end
+
+            def eat_ghost?(power_pellet_active, touching_ghost) do
+              BooleanLogic.do_and(power_pellet_active, touching_ghost)
+            end
+          end
+        end
+
+      assert PrivateHelperFunctions.run(code, @pacman_exemplar) == []
+    end
+
+    test "@impl true hides the function" do
+      code =
+        quote do
+          defmodule Rules do
+            defmodule BooleanLogic do
+              @impl true
+              def do_or(left, right), do: left or right
+
+              @impl true
+              def do_and(left, right) when is_boolean(left), do: left and right
+            end
+
+            def score?(touching_power_pellet, touching_dot) do
+              BooleanLogic.do_or(touching_power_pellet, touching_dot)
+            end
+
+            def eat_ghost?(power_pellet_active, touching_ghost) do
+              BooleanLogic.do_and(power_pellet_active, touching_ghost)
+            end
+          end
+        end
+
+      assert PrivateHelperFunctions.run(code, @pacman_exemplar) == []
+    end
   end
 
   describe "practice exercise with square-root" do