From 7f2f4f413348dc33d55ea17c2473007518627320 Mon Sep 17 00:00:00 2001 From: Nikola Jichev Date: Wed, 1 May 2024 15:36:38 +0300 Subject: [PATCH] feat: add remove debugger code action (#426) * feat: add remove debugger code action A Code Action that removes the following warning checks from Credo: - Credo.Check.Warning.Dbg - Credo.Check.Warning.IExPry - Credo.Check.Warning.IoInspect - Credo.Check.Warning.IoPuts - Credo.Check.Warning.MixEnv Co-authored-by: Mitchell Hanberg --- .../extensions/credo_extension/code_action.ex | 18 +- .../code_action/remove_debugger.ex | 149 ++++++++ mix.exs | 2 +- mix.lock | 2 +- .../credo_extension/remove_debugger_test.exs | 346 ++++++++++++++++++ .../elixir_extension/code_action_test.exs | 63 +++- test/support/utils.ex | 32 ++ 7 files changed, 607 insertions(+), 5 deletions(-) create mode 100644 lib/next_ls/extensions/credo_extension/code_action/remove_debugger.ex create mode 100644 test/next_ls/extensions/credo_extension/remove_debugger_test.exs diff --git a/lib/next_ls/extensions/credo_extension/code_action.ex b/lib/next_ls/extensions/credo_extension/code_action.ex index 0a7e6303..3edf79c1 100644 --- a/lib/next_ls/extensions/credo_extension/code_action.ex +++ b/lib/next_ls/extensions/credo_extension/code_action.ex @@ -4,7 +4,23 @@ defmodule NextLS.CredoExtension.CodeAction do @behaviour NextLS.CodeActionable alias NextLS.CodeActionable.Data + alias NextLS.CredoExtension.CodeAction.RemoveDebugger + @debug_checks ~w( + Elixir.Credo.Check.Warning.Dbg + Elixir.Credo.Check.Warning.IExPry + Elixir.Credo.Check.Warning.IoInspect + Elixir.Credo.Check.Warning.IoPuts + Elixir.Credo.Check.Warning.MixEnv + ) @impl true - def from(%Data{} = _data), do: [] + def from(%Data{} = data) do + case data.diagnostic.data do + %{"check" => check} when check in @debug_checks -> + RemoveDebugger.new(data.diagnostic, data.document, data.uri) + + _ -> + [] + end + end end diff --git a/lib/next_ls/extensions/credo_extension/code_action/remove_debugger.ex b/lib/next_ls/extensions/credo_extension/code_action/remove_debugger.ex new file mode 100644 index 00000000..19ce29fc --- /dev/null +++ b/lib/next_ls/extensions/credo_extension/code_action/remove_debugger.ex @@ -0,0 +1,149 @@ +defmodule NextLS.CredoExtension.CodeAction.RemoveDebugger do + @moduledoc false + + alias GenLSP.Structures.CodeAction + alias GenLSP.Structures.Diagnostic + alias GenLSP.Structures.Position + alias GenLSP.Structures.Range + alias GenLSP.Structures.TextEdit + alias GenLSP.Structures.WorkspaceEdit + alias NextLS.EditHelpers + alias Sourceror.Zipper, as: Z + + @line_length 121 + + def new(%Diagnostic{} = diagnostic, text, uri) do + range = diagnostic.range + + with {:ok, ast, comments} <- parse(text), + {:ok, debugger_node} <- find_debugger(ast, range) do + indent = EditHelpers.get_indent(text, range.start.line) + ast_without_debugger = remove_debugger(debugger_node) + range = make_range(debugger_node) + + comments = + Enum.filter(comments, fn comment -> + comment.line > range.start.line && comment.line <= range.end.line + end) + + to_algebra_opts = [comments: comments] + doc = Code.quoted_to_algebra(ast_without_debugger, to_algebra_opts) + formatted = doc |> Inspect.Algebra.format(@line_length) |> IO.iodata_to_binary() + + [ + %CodeAction{ + title: make_title(debugger_node), + diagnostics: [diagnostic], + edit: %WorkspaceEdit{ + changes: %{ + uri => [ + %TextEdit{ + new_text: EditHelpers.add_indent_to_edit(formatted, indent), + range: range + } + ] + } + } + } + ] + else + _ -> + [] + end + end + + defp find_debugger(ast, range) do + pos = %{ + start: [line: range.start.line + 1, column: range.start.character + 1], + end: [line: range.end.line + 1, column: range.end.character + 1] + } + + {_, results} = + ast + |> Z.zip() + |> Z.traverse([], fn tree, acc -> + node = Z.node(tree) + range = Sourceror.get_range(node) + + # range.start <= diagnostic_pos.start <= diagnostic_pos.end <= range.end + if (matches_debug?(node) || matches_pipe?(node)) && range && + Sourceror.compare_positions(range.start, pos.start) in [:lt, :eq] && + Sourceror.compare_positions(range.end, pos.end) in [:gt, :eq] do + {tree, [node | acc]} + else + {tree, acc} + end + end) + + result = + Enum.min_by( + results, + fn node -> + range = Sourceror.get_range(node) + + pos.start[:column] - range.start[:column] + range.end[:column] - pos.end[:column] + end, + fn -> nil end + ) + + result = + Enum.find(results, result, fn + {:|>, _, [_first, ^result]} -> true + _ -> false + end) + + case result do + nil -> {:error, "could find a debugger to remove"} + node -> {:ok, node} + end + end + + defp parse(lines) do + lines + |> Enum.join("\n") + |> Spitfire.parse_with_comments(literal_encoder: &{:ok, {:__block__, &2, [&1]}}) + |> case do + {:error, ast, comments, _errors} -> + {:ok, ast, comments} + + other -> + other + end + end + + defp make_range(original_ast) do + range = Sourceror.get_range(original_ast) + + %Range{ + start: %Position{line: range.start[:line] - 1, character: range.start[:column] - 1}, + end: %Position{line: range.end[:line] - 1, character: range.end[:column] - 1} + } + end + + defp matches_pipe?({:|>, _, [_, arg]}), do: matches_debug?(arg) + defp matches_pipe?(_), do: false + + defp matches_debug?({:dbg, _, _}), do: true + + defp matches_debug?({{:., _, [{:__aliases__, _, [:IO]}, f]}, _, _}) when f in [:puts, :inspect], do: true + + defp matches_debug?({{:., _, [{:__aliases__, _, [:IEx]}, :pry]}, _, _}), do: true + defp matches_debug?({{:., _, [{:__aliases__, _, [:Mix]}, :env]}, _, _}), do: true + defp matches_debug?({{:., _, [{:__aliases__, _, [:Kernel]}, :dbg]}, _, _}), do: true + defp matches_debug?(_), do: false + + defp remove_debugger({:|>, _, [arg, _function]}), do: arg + defp remove_debugger({{:., _, [{:__aliases__, _, [:IO]}, :inspect]}, _, [arg | _]}), do: arg + defp remove_debugger({{:., _, [{:__aliases__, _, [:Kernel]}, :dbg]}, _, [arg | _]}), do: arg + defp remove_debugger({:dbg, _, [arg | _]}), do: arg + defp remove_debugger(_node), do: {:__block__, [], []} + + defp make_title({_, ctx, _} = node), do: "Remove `#{format_node(node)}` #{ctx[:line]}:#{ctx[:column]}" + defp format_node({:|>, _, [_arg, function]}), do: format_node(function) + + defp format_node({{:., _, [{:__aliases__, _, [module]}, function]}, _, args}), + do: "&#{module}.#{function}/#{Enum.count(args)}" + + defp format_node({:dbg, _, args}), do: "&dbg/#{Enum.count(args)}" + defp format_node(node), do: Macro.to_string(node) +end diff --git a/mix.exs b/mix.exs index 44d844eb..90c1c351 100644 --- a/mix.exs +++ b/mix.exs @@ -76,7 +76,7 @@ defmodule NextLS.MixProject do {:burrito, "~> 1.0", only: [:dev, :prod]}, {:bypass, "~> 2.1", only: :test}, {:dialyxir, ">= 0.0.0", only: [:dev, :test], runtime: false}, - {:credo, "~> 1.7", only: [:dev, :test], runtime: false}, + {:credo, github: "rrrene/credo", branch: "master", only: [:dev, :test], runtime: false}, {:ex_doc, ">= 0.0.0", only: :dev}, {:styler, "~> 0.8", only: :dev} ] diff --git a/mix.lock b/mix.lock index b4c863cd..bd9d3256 100644 --- a/mix.lock +++ b/mix.lock @@ -9,7 +9,7 @@ "cowboy": {:hex, :cowboy, "2.10.0", "ff9ffeff91dae4ae270dd975642997afe2a1179d94b1887863e43f681a203e26", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "3afdccb7183cc6f143cb14d3cf51fa00e53db9ec80cdcd525482f5e99bc41d6b"}, "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"}, "cowlib": {:hex, :cowlib, "2.12.1", "a9fa9a625f1d2025fe6b462cb865881329b5caff8f1854d1cbc9f9533f00e1e1", [:make, :rebar3], [], "hexpm", "163b73f6367a7341b33c794c4e88e7dbfe6498ac42dcd69ef44c5bc5507c8db0"}, - "credo": {:hex, :credo, "1.7.5", "643213503b1c766ec0496d828c90c424471ea54da77c8a168c725686377b9545", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "f799e9b5cd1891577d8c773d245668aa74a2fcd15eb277f51a0131690ebfb3fd"}, + "credo": {:git, "https://github.com/rrrene/credo.git", "3612dc2417455c2487043bf947b048b90a882b47", [branch: "master"]}, "ctx": {:hex, :ctx, "0.6.0", "8ff88b70e6400c4df90142e7f130625b82086077a45364a78d208ed3ed53c7fe", [:rebar3], [], "hexpm", "a14ed2d1b67723dbebbe423b28d7615eb0bdcba6ff28f2d1f1b0a7e1d4aa5fc2"}, "db_connection": {:hex, :db_connection, "2.5.0", "bb6d4f30d35ded97b29fe80d8bd6f928a1912ca1ff110831edcd238a1973652c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c92d5ba26cd69ead1ff7582dbb860adeedfff39774105a4f1c92cbb654b55aa2"}, "dialyxir": {:hex, :dialyxir, "1.4.3", "edd0124f358f0b9e95bfe53a9fcf806d615d8f838e2202a9f430d59566b6b53b", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "bf2cfb75cd5c5006bec30141b131663299c661a864ec7fbbc72dfa557487a986"}, diff --git a/test/next_ls/extensions/credo_extension/remove_debugger_test.exs b/test/next_ls/extensions/credo_extension/remove_debugger_test.exs new file mode 100644 index 00000000..64987012 --- /dev/null +++ b/test/next_ls/extensions/credo_extension/remove_debugger_test.exs @@ -0,0 +1,346 @@ +defmodule NextLS.CredoExtension.CodeAction.RemoveDebuggerTest do + use ExUnit.Case, async: true + + import NextLS.Support.Utils, only: [assert_is_text_edit: 3] + + alias GenLSP.Structures.CodeAction + alias GenLSP.Structures.Position + alias GenLSP.Structures.Range + alias GenLSP.Structures.TextEdit + alias GenLSP.Structures.WorkspaceEdit + alias NextLS.CredoExtension.CodeAction.RemoveDebugger + + @uri "file:///home/owner/my_project/hello.ex" + + test "removes debugger checks" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + IO.inspect(arg) + foo(arg) + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg + foo(arg) + end + end + """) + + start = %Position{character: 4, line: 2} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + assert is_struct(code_action, CodeAction) + assert [diagnostic] == code_action.diagnostics + assert code_action.title == "Remove `&IO.inspect/1` 3:8" + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "works for all credo checks" do + checks = [ + {"Elixir.Credo.Check.Warning.Dbg", "dbg()", "dbg/0", ""}, + {"Elixir.Credo.Check.Warning.Dbg", "dbg(arg)", "dbg/1", "arg"}, + {"Elixir.Credo.Check.Warning.Dbg", "Kernel.dbg()", "Kernel.dbg/0", ""}, + {"Elixir.Credo.Check.Warning.IExPry", "IEx.pry()", "IEx.pry/0", ""}, + {"Elixir.Credo.Check.Warning.IoInspect", "IO.inspect(foo, label: ~s/bar/)", "IO.inspect/2", "foo"}, + {"Elixir.Credo.Check.Warning.IoPuts", "IO.puts(arg)", "IO.puts/1", ""}, + {"Elixir.Credo.Check.Warning.MixEnv", "Mix.env()", "Mix.env/0", ""} + ] + + for {check, code, title, edit} <- checks do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + #{code} + arg + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + #{edit} + arg + end + end + """) + + start = %Position{character: 4, line: 2} + diagnostic = get_diagnostic(start, check: check, code: code) + title = "Remove `&#{title}` #{start.line + 1}" + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + assert code_action.title =~ title + + assert %WorkspaceEdit{ + changes: %{ + @uri => [%TextEdit{} = edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + end + + test "works on multiple expressions on one line" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + IO.inspect(arg, label: "Debugging"); world(arg) + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg; world(arg) + end + end + """) + + start = %Position{character: 4, line: 2} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "handles pipe calls in the middle" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + arg + |> Enum.map(&(&1 * &1)) + |> IO.inspect(label: "FOO") + |> Enum.sum() + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg + |> Enum.map(&(&1 * &1)) + |> Enum.sum() + end + end + """) + + start = %Position{character: 10, line: 4} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "handles pipe calls at the end" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + arg + |> Enum.map(&(&1 * &1)) + |> Enum.sum() + |> IO.inspect() + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg + |> Enum.map(&(&1 * &1)) + |> Enum.sum() + end + end + """) + + start = %Position{character: 10, line: 5} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "handles pipe calls after an expr" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + arg |> IO.inspect() + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg + end + end + """) + + start = %Position{character: 10, line: 2} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "handles functions with only one expression" do + text = + String.split( + """ + defmodule Test.Debug do + def hello(arg) do + IO.inspect(arg, label: "DEBUG") + end + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + def hello(arg) do + arg + end + end + """) + + start = %Position{character: 4, line: 2} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + test "handles inspects in module bodies" do + text = + String.split( + """ + defmodule Test.Debug do + @attr "foo" + IO.inspect(@attr) + end + """, + "\n" + ) + + expected = + String.trim(""" + defmodule Test.Debug do + @attr "foo" + @attr + end + """) + + start = %Position{character: 4, line: 2} + diagnostic = get_diagnostic(start) + + assert [code_action] = RemoveDebugger.new(diagnostic, text, @uri) + + assert %WorkspaceEdit{ + changes: %{ + @uri => [edit] + } + } = code_action.edit + + assert_is_text_edit(text, edit, expected) + end + + defp get_diagnostic(start, opts \\ []) do + check = Keyword.get(opts, :check, "Elixir.Credo.Check.Warning.IoInspect") + code = Keyword.get(opts, :code, "IO.inspect/2") + + %GenLSP.Structures.Diagnostic{ + data: %{"namespace" => "credo", "check" => check}, + message: "There should be no calls to `#{code}`", + source: "Elixir", + range: %Range{ + start: start, + end: start + } + } + end +end diff --git a/test/next_ls/extensions/elixir_extension/code_action_test.exs b/test/next_ls/extensions/elixir_extension/code_action_test.exs index 09fd4846..58e86d9b 100644 --- a/test/next_ls/extensions/elixir_extension/code_action_test.exs +++ b/test/next_ls/extensions/elixir_extension/code_action_test.exs @@ -14,6 +14,7 @@ defmodule NextLS.Extensions.ElixirExtension.CodeActionTest do cwd = Path.join(tmp_dir, "my_proj") foo_path = Path.join(cwd, "lib/foo.ex") + bar_path = Path.join(cwd, "lib/bar.ex") foo = """ defmodule MyProj.Foo do @@ -28,9 +29,20 @@ defmodule NextLS.Extensions.ElixirExtension.CodeActionTest do end """ + bar = """ + defmodule MyProj.Bar do + def foo() do + a = :bar + foo(dbg(a), IO.inspect(a)) + a + end + end + """ + File.write!(foo_path, foo) + File.write!(bar_path, bar) - [foo: foo, foo_path: foo_path] + [foo: foo, foo_path: foo_path, bar: bar, bar_path: bar_path] end setup :with_lsp @@ -42,6 +54,7 @@ defmodule NextLS.Extensions.ElixirExtension.CodeActionTest do assert_notification "$/progress", %{"value" => %{"kind" => "end", "message" => "Finished indexing!"}} did_open(context.client, context.foo_path, context.foo) + did_open(context.client, context.bar_path, context.bar) context end @@ -60,7 +73,7 @@ defmodule NextLS.Extensions.ElixirExtension.CodeActionTest do "data" => %{"namespace" => "elixir", "type" => "unused_variable"}, "message" => "variable \"foo\" is unused (if the variable is not meant to be used, prefix it with an underscore)", - "range" => %{"end" => %{"character" => 999, "line" => 2}, "start" => %{"character" => 4, "line" => 2}}, + "range" => %{"end" => %{"character" => 999, "line" => 3}, "start" => %{"character" => 4, "line" => 3}}, "severity" => 2, "source" => "Elixir" } @@ -122,4 +135,50 @@ defmodule NextLS.Extensions.ElixirExtension.CodeActionTest do }, 500 end + + test "sends back a remove inspect action", %{client: client, bar_path: bar} do + bar_uri = uri(bar) + id = 1 + + request client, %{ + method: "textDocument/codeAction", + id: id, + jsonrpc: "2.0", + params: %{ + context: %{ + "diagnostics" => [ + %{ + "data" => %{"namespace" => "credo", "check" => "Elixir.Credo.Check.Warning.Dbg"}, + "message" => "There should be no calls to `dbg/1`.", + "range" => %{"end" => %{"character" => 13, "line" => 3}, "start" => %{"character" => 8, "line" => 3}}, + "severity" => 2, + "source" => "Elixir" + }, + %{ + "data" => %{"namespace" => "credo", "check" => "Elixir.Credo.Check.Warning.IoInspect"}, + "message" => "There should be no calls to `IO.inspect/1`.", + "range" => %{"end" => %{"character" => 28, "line" => 3}, "start" => %{"character" => 20, "line" => 3}}, + "severity" => 2, + "source" => "Elixir" + } + ] + }, + range: %{start: %{line: 0, character: 0}, end: %{line: 7, character: 999}}, + textDocument: %{uri: bar_uri} + } + } + + assert_receive %{ + "jsonrpc" => "2.0", + "id" => 1, + "result" => [ + %{"edit" => %{"changes" => %{^bar_uri => [%{"newText" => "a", "range" => range1}]}}}, + %{"edit" => %{"changes" => %{^bar_uri => [%{"newText" => "a", "range" => range2}]}}} + ] + }, + 500 + + assert %{"start" => %{"character" => 8, "line" => 3}, "end" => %{"character" => 14, "line" => 3}} == range1 + assert %{"start" => %{"character" => 16, "line" => 3}, "end" => %{"character" => 29, "line" => 3}} == range2 + end end diff --git a/test/support/utils.ex b/test/support/utils.ex index fe063d22..c470c3f7 100644 --- a/test/support/utils.ex +++ b/test/support/utils.ex @@ -4,6 +4,10 @@ defmodule NextLS.Support.Utils do import ExUnit.Callbacks import GenLSP.Test + alias GenLSP.Structures.Position + alias GenLSP.Structures.Range + alias GenLSP.Structures.TextEdit + def mix_exs do """ defmodule Project.MixProject do @@ -172,4 +176,32 @@ defmodule NextLS.Support.Utils do }) end end + + def apply_edit(code, edit) when is_binary(code), do: apply_edit(String.split(code, "\n"), edit) + + def apply_edit(lines, %TextEdit{} = edit) when is_list(lines) do + text = edit.new_text + %Range{start: %Position{line: startl, character: startc}, end: %Position{line: endl, character: endc}} = edit.range + + startl_text = Enum.at(lines, startl) + prefix = String.slice(startl_text, 0, startc) + + endl_text = Enum.at(lines, endl) + suffix = String.slice(endl_text, endc, String.length(endl_text) - endc) + + replacement = prefix <> text <> suffix + + new_lines = Enum.slice(lines, 0, startl) ++ [replacement] ++ Enum.slice(lines, endl + 1, Enum.count(lines)) + + new_lines + |> Enum.join("\n") + |> String.trim() + end + + defmacro assert_is_text_edit(code, edit, expected) do + quote do + actual = unquote(__MODULE__).apply_edit(unquote(code), unquote(edit)) + assert actual == unquote(expected) + end + end end