Normalize boolean operators and expand ~w sigils

Canonicalize &&/||/! to and/or/not so stylistic choice between
short-circuit and keyword operators doesn't prevent clone matching.

Expand static ~w(...)a/s/c sigils to their literal list form so
~w(foo bar)a matches [:foo, :bar].

Author: dannote

lib/ex_dna/ast/normalizer.ex

@@ -13,9 +13,15 @@ defmodule ExDNA.AST.Normalizer do
      placeholders (`:$0`, `:$1`, …) based on first-occurrence order.
   3. **Literal abstraction** (optional) — replaces concrete literals with
      type-tagged placeholders to detect Type-II clones.
-  4. **Map/struct field sorting** (abstract mode) — sorts key-value pairs
+  4. **Boolean operator canonicalization** — `&&`/`||`/`!` are rewritten to
+     `and`/`or`/`not` so stylistic choice between short-circuit and keyword
+     operators doesn’t affect comparison.
+  5. **Sigil expansion** — `~w(foo bar)a` is expanded to `[:foo, :bar]` (and
+     likewise for string modifiers) so sigil word-lists match their literal
+     equivalents.
+  6. **Map/struct field sorting** (abstract mode) — sorts key-value pairs
      so that `%{b: 1, a: 2}` and `%{a: 2, b: 1}` produce the same hash.
-  5. **Guard abstraction** (abstract mode) — in `when` clauses, replaces
+  7. **Guard abstraction** (abstract mode) — in `when` clauses, replaces
      all function/macro call names with a `:__guard__` placeholder so that
      `when is_binary(x)` and `when is_atom(x)` produce the same hash.
      Covers all Kernel guards, Erlang BIF guards, `defguard` macros,
@@ -44,6 +50,8 @@ defmodule ExDNA.AST.Normalizer do
 
     ast
     |> strip_metadata()
+    |> canonicalize_operators()
+    |> expand_sigils()
     |> maybe_normalize_pipes(normalize_pipes)
     |> normalize_variables()
     |> maybe_abstract_literals(literal_mode)
@@ -94,6 +102,39 @@ defmodule ExDNA.AST.Normalizer do
 
   defp rename_var(node, env), do: {node, env}
 
+  @bool_canon %{:&& => :and, :|| => :or, :! => :not}
+
+  defp canonicalize_operators(ast) do
+    Macro.prewalk(ast, fn
+      {op, meta, args} when is_map_key(@bool_canon, op) ->
+        {@bool_canon[op], meta, args}
+
+      other ->
+        other
+    end)
+  end
+
+  defp expand_sigils(ast) do
+    Macro.prewalk(ast, fn
+      {:sigil_w, _meta, [{:<<>>, _, [content]}, modifier]}
+      when is_binary(content) ->
+        expand_sigil_w(content, modifier)
+
+      other ->
+        other
+    end)
+  end
+
+  defp expand_sigil_w(content, modifier) do
+    words = String.split(content)
+
+    case modifier do
+      ~c"a" -> Enum.map(words, &String.to_atom/1)
+      ~c"c" -> Enum.map(words, &String.to_charlist/1)
+      _ -> words
+    end
+  end
+
   defp maybe_normalize_pipes(ast, false), do: ast
   defp maybe_normalize_pipes(ast, true), do: PipeNormalizer.normalize(ast)
 

test/ex_dna/ast/normalizer_test.exs

@@ -50,6 +50,67 @@ defmodule ExDNA.AST.NormalizerTest do
     end
   end
 
+  describe "boolean operator canonicalization" do
+    test "&& and 'and' produce identical normalized AST" do
+      ast1 = Code.string_to_quoted!("a && b")
+      ast2 = Code.string_to_quoted!("a and b")
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "|| and 'or' produce identical normalized AST" do
+      ast1 = Code.string_to_quoted!("a || b")
+      ast2 = Code.string_to_quoted!("a or b")
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "! and 'not' produce identical normalized AST" do
+      ast1 = Code.string_to_quoted!("!a")
+      ast2 = Code.string_to_quoted!("not a")
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "nested boolean operators are canonicalized" do
+      ast1 = Code.string_to_quoted!("a && b || !c")
+      ast2 = Code.string_to_quoted!("a and b or not c")
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+  end
+
+  describe "sigil expansion" do
+    test "~w()a matches atom list" do
+      ast1 = Code.string_to_quoted!("~w(foo bar baz)a")
+      ast2 = Code.string_to_quoted!("[:foo, :bar, :baz]")
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "~w()s matches string list" do
+      ast1 = Code.string_to_quoted!("~w(foo bar)s")
+      ast2 = Code.string_to_quoted!(~s(["foo", "bar"]))
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "~w() without modifier matches string list" do
+      ast1 = Code.string_to_quoted!("~w(hello world)")
+      ast2 = Code.string_to_quoted!(~s(["hello", "world"]))
+
+      assert Normalizer.normalize(ast1) == Normalizer.normalize(ast2)
+    end
+
+    test "~w with interpolation is not expanded" do
+      ast = Code.string_to_quoted!(~S"~w(foo #{x} bar)a")
+      norm = Normalizer.normalize(ast)
+
+      {form, _, _} = norm
+      assert form == :sigil_w
+    end
+  end
+
   describe "normalize/2 with literal_mode: :keep" do
     test "identical code produces identical normalized AST" do
       code = "fn(a, b) -> a + b end"