test: recognise fully qualified Mix.Tasks aliases

`defmodule Elixir.Mix.Tasks.Castle.X` names the same module as
`defmodule Mix.Tasks.Castle.X`, but parses to an alias with an extra
leading segment - `[Elixir, :Mix, :Tasks, ...]` rather than
`[:Mix, :Tasks, ...]` - so the matcher walked straight past it. Guarded
by a `Mix.env()` branch it was invisible to the beam check as well, which
is the state the two checks exist to make impossible between them.

Recognition now strips the leading `Elixir` before testing the segments.
`Module.concat/1` already renders both spellings as `Mix.Tasks.Castle.X`,
so only the recognition needed to know about the prefix, and the reported
name is unchanged.

A case pins the qualified form inside an environment branch, alongside
the parenthesised and literal-atom ones. Verified against a planted
`lib/mix/tasks/qualified.ex`, which the source check now reports and the
test-environment beam check still cannot see.

Claude-Session: https://claude.ai/code/session_01RotroiBdbidiCRX3KqE3Dy

Author: ausimian

AGENTS.md

@@ -1663,9 +1663,11 @@ the entries, and `castle.ex` among the sources, because an empty directory
 filters to no tasks and that is indistinguishable from a clean result.
 
 **What the source check enforces is narrower than "no task in `lib`", and the
-difference is on the record rather than assumed.** It matches the two forms a
-module name is *written* in — an alias, `defmodule Mix.Tasks.X`, and a literal
-atom, `defmodule :"Elixir.Mix.Tasks.X"`. It does not *resolve* names, so
+difference is on the record rather than assumed.** It matches the forms a module
+name is *written* in — an alias, `defmodule Mix.Tasks.X`; the same alias fully
+qualified, `defmodule Elixir.Mix.Tasks.X`, which parses with an extra leading
+segment; and a literal atom, `defmodule :"Elixir.Mix.Tasks.X"`. It does not
+*resolve* names, so
 `alias Mix.Tasks, as: N` followed by `defmodule N.Castle.X` defines the module
 and is invisible to it, as are a name built by `Module.concat/1`, one produced
 by a macro, and `Module.create/3`. Doing better means implementing alias scoping

test/castle/no_mix_tasks_test.exs

@@ -139,6 +139,24 @@ defmodule Castle.NoMixTasksTest do
     assert task_definitions(@heredoc_sample, "docs.ex") == []
   end
 
+  # `Elixir.Mix.Tasks.X` names the same module as `Mix.Tasks.X` and parses with
+  # an extra leading segment, which the first version of the matcher did not
+  # expect. Guarded by an environment branch it was invisible to the beam check
+  # too, so it escaped the pair the same way the parenthesised form did.
+  test "the source check sees a fully qualified alias" do
+    source = ~S"""
+    if Mix.env() == :prod do
+      defmodule Elixir.Mix.Tasks.Castle.Qualified do
+        use Mix.Task
+      end
+    end
+    """
+
+    assert task_definitions(source, "qualified.ex") == [
+             "qualified.ex:2: Mix.Tasks.Castle.Qualified"
+           ]
+  end
+
   # The other written form of a module name.
   test "the source check sees a literal atom module name" do
     source = ~S"""
@@ -171,8 +189,9 @@ defmodule Castle.NoMixTasksTest do
   # AST node whatever the spacing, parenthesisation or line breaks around it
   # are, and text inside a string literal is a binary in that AST rather than a
   # node - so both of the cases above fall out of asking the parser instead of
-  # the characters. It matches the two forms a module name is *written* in: an
-  # alias (`Mix.Tasks.X`) and a literal atom (`:"Elixir.Mix.Tasks.X"`).
+  # the characters. It matches the forms a module name is *written* in: an alias
+  # (`Mix.Tasks.X`), the same alias fully qualified (`Elixir.Mix.Tasks.X`), and a
+  # literal atom (`:"Elixir.Mix.Tasks.X"`).
   #
   # **What it does not do is resolve names, and that is a deliberate limit
   # rather than an oversight.** `alias Mix.Tasks, as: N` followed by
@@ -200,8 +219,10 @@ defmodule Castle.NoMixTasksTest do
 
     {_ast, found} =
       Macro.prewalk(ast, [], fn
-        {:defmodule, meta, [{:__aliases__, _, [:Mix, :Tasks | _] = segments} | _]} = node, acc ->
-          {node, [{line(meta), Module.concat(segments)} | acc]}
+        {:defmodule, meta, [{:__aliases__, _, segments} | _]} = node, acc ->
+          if task_alias?(segments),
+            do: {node, [{line(meta), Module.concat(segments)} | acc]},
+            else: {node, acc}
 
         {:defmodule, meta, [module | _]} = node, acc when is_atom(module) ->
           if match?("Elixir.Mix.Tasks." <> _, Atom.to_string(module)),
@@ -217,5 +238,13 @@ defmodule Castle.NoMixTasksTest do
     |> Enum.map(fn {line, module} -> "#{label}:#{line}: #{inspect(module)}" end)
   end
 
+  # `Mix.Tasks.X` parses to `[:Mix, :Tasks, :X]`, and the fully qualified
+  # `Elixir.Mix.Tasks.X` to `[Elixir, :Mix, :Tasks, :X]` - the same module,
+  # written twice. `Module.concat/1` already renders both as `Mix.Tasks.X`, so
+  # only the recognition needs to know about the prefix.
+  defp task_alias?([Elixir | rest]), do: task_alias?(rest)
+  defp task_alias?([:Mix, :Tasks | _]), do: true
+  defp task_alias?(_segments), do: false
+
   defp line(meta), do: Keyword.get(meta, :line, 0)
 end