Require tail-call recursion in dna-encoding (#374)

Author: angelikatyborska

lib/elixir_analyzer/constants.ex

@@ -84,6 +84,7 @@ defmodule ElixirAnalyzer.Constants do
 
     # DNA Encoding Comments
     dna_encoding_use_recursion: "elixir.dna-encoding.use_recursion",
+    dna_encoding_use_tail_call_recursion: "elixir.dna-encoding.use_tail_call_recursion",
 
     # File Sniffer Comments
     file_sniffer_use_pattern_matching: "elixir.file-sniffer.use_pattern_matching",

lib/elixir_analyzer/exercise_test/check_source/compiler.ex

@@ -20,10 +20,21 @@ defmodule ElixirAnalyzer.ExerciseTest.CheckSource.Compiler do
 
     quote do
       (fn %Source{} = source ->
-         if unquote(check_function).(source) do
-           {:pass, unquote(test_description)}
-         else
-           {:fail, unquote(test_description)}
+         case unquote(check_function).(source) do
+           true ->
+             {:pass, unquote(test_description)}
+
+           false ->
+             {:fail, unquote(test_description)}
+
+           {true, params} when is_map(params) ->
+             {:pass, %{unquote(test_description) | params: params}}
+
+           {false, params} when is_map(params) ->
+             {:fail, %{unquote(test_description) | params: params}}
+
+           _ ->
+             raise "check must be a boolean or a tuple with a boolean and a map of parameters for the comment"
          end
        end).(unquote(code_source))
     end

lib/elixir_analyzer/test_suite/dna_encoding.ex

@@ -5,6 +5,7 @@ defmodule ElixirAnalyzer.TestSuite.DNAEncoding do
 
   use ElixirAnalyzer.ExerciseTest
   alias ElixirAnalyzer.Constants
+  alias ElixirAnalyzer.Source
 
   assert_no_call "does not call any Enum functions" do
     type :essential
@@ -29,4 +30,131 @@ defmodule ElixirAnalyzer.TestSuite.DNAEncoding do
     called_fn name: :for
     comment Constants.dna_encoding_use_recursion()
   end
+
+  check_source "uses tail call recursion" do
+    type :essential
+    suppress_if "does not call any Enum functions", :fail
+    suppress_if "does not call any Stream functions", :fail
+    suppress_if "does not call any List functions", :fail
+    suppress_if "does not use list comprehensions", :fail
+    comment Constants.dna_encoding_use_tail_call_recursion()
+
+    check(%Source{code_ast: code_ast}) do
+      {_, tail_call_recursive_functions} =
+        Macro.prewalk(
+          code_ast,
+          [],
+          fn node, acc -> find_tail_call_recursive_functions(node, acc) end
+        )
+
+      tail_call_recursive_functions = Enum.uniq(tail_call_recursive_functions)
+
+      {_, all_recursive_functions} =
+        Macro.prewalk(
+          code_ast,
+          [],
+          fn node, acc -> find_all_recursive_functions(node, acc) end
+        )
+
+      all_recursive_functions = Enum.uniq(all_recursive_functions)
+
+      non_tail_call_recursive_functions = all_recursive_functions -- tail_call_recursive_functions
+
+      if non_tail_call_recursive_functions != [] || tail_call_recursive_functions == [] do
+        {false,
+         %{
+           non_tail_call_recursive_functions:
+             format_function_names(non_tail_call_recursive_functions),
+           tail_call_recursive_functions: format_function_names(tail_call_recursive_functions)
+         }}
+      else
+        true
+      end
+    end
+  end
+
+  defp format_function_names(list) do
+    if list == [] do
+      "none"
+    else
+      Enum.map(list, fn {name, arity} -> "`#{name}/#{arity}`" end)
+      |> Enum.join(", ")
+    end
+  end
+
+  defp find_tail_call_recursive_functions(node, acc) do
+    acc =
+      case node do
+        {op, _meta1, [{:when, _meta2, [{fn_name, _meta3, args} | _]}, opts]}
+        when op in [:def, :defp] ->
+          check_if_function_tail_call_recursive(acc, fn_name, args, opts)
+
+        {op, _meta1, [{fn_name, _meta2, args}, opts]} when op in [:def, :defp] ->
+          check_if_function_tail_call_recursive(acc, fn_name, args, opts)
+
+        _ ->
+          acc
+      end
+
+    {node, acc}
+  end
+
+  defp check_if_function_tail_call_recursive(acc, fn_name, args, opts) do
+    fn_arity = length(args)
+
+    last_call_in_function_def =
+      case opts[:do] do
+        {:__block, _, calls} when is_list(calls) ->
+          List.last(calls)
+
+        calls when is_list(calls) ->
+          List.last(calls)
+
+        call ->
+          call
+      end
+
+    case last_call_in_function_def do
+      {^fn_name, _meta3, args} when length(args) == fn_arity ->
+        [{fn_name, fn_arity} | acc]
+
+      _ ->
+        acc
+    end
+  end
+
+  defp find_all_recursive_functions(node, acc) do
+    acc =
+      case node do
+        {op, _meta1, [{:when, _meta2, [{fn_name, _meta3, args} | _]}, opts]}
+        when op in [:def, :defp] ->
+          check_if_function_recursive(acc, fn_name, args, opts)
+
+        {op, _meta1, [{fn_name, _meta2, args}, opts]} when op in [:def, :defp] ->
+          check_if_function_recursive(acc, fn_name, args, opts)
+
+        _ ->
+          acc
+      end
+
+    {node, acc}
+  end
+
+  defp check_if_function_recursive(acc, fn_name, args, opts) do
+    fn_arity = length(args)
+
+    {_, any_nested_recursive_calls?} =
+      Macro.prewalk(opts[:do], false, fn node, acc ->
+        case node do
+          {^fn_name, _, args} when length(args) == fn_arity -> {node, true}
+          _ -> {node, acc}
+        end
+      end)
+
+    if any_nested_recursive_calls? do
+      [{fn_name, fn_arity} | acc]
+    else
+      acc
+    end
+  end
 end

test/elixir_analyzer/exercise_test/check_source_test.exs

@@ -2,6 +2,8 @@ defmodule ElixirAnalyzer.ExerciseTest.CheckSourceTest do
   use ElixirAnalyzer.ExerciseTestCase,
     exercise_test_module: ElixirAnalyzer.Support.AnalyzerVerification.CheckSource
 
+  alias ElixirAnalyzer.Submission
+
   test_exercise_analysis "empty module",
     comments: ["always return false", "didn't use multiline"] do
     ~S"""
@@ -206,4 +208,33 @@ defmodule ElixirAnalyzer.ExerciseTest.CheckSourceTest do
       end
     end
   end
+
+  test "allows passing comment params" do
+    code_string = ~S"""
+    defmodule Fruits do
+      @best_fruit = "banana"
+      @best_fruit_for_breakfast = "banana"
+      @best_fruit_for_a_snack = "banana"
+    end
+    """
+
+    source =
+      ElixirAnalyzer.ExerciseTestCase.find_source(
+        ElixirAnalyzer.Support.AnalyzerVerification.CheckSource
+      )
+
+    result =
+      ElixirAnalyzer.Support.AnalyzerVerification.CheckSource.analyze(%Submission{
+        source: %{source | code_string: code_string},
+        analysis_module: ElixirAnalyzer.Support.AnalyzerVerification.CheckSource
+      })
+
+    comment = Enum.find(result.comments, fn comment -> comment.comment == "even banana count" end)
+
+    assert comment == %{
+             comment: "even banana count",
+             params: %{banana_count: 3},
+             type: :actionable
+           }
+  end
 end