add support for __MODULE__ special form in alias, require and import expressions (#56)

Author: lukaszsamson

lib/elixir_sense/core/metadata_builder.ex

@@ -268,11 +268,11 @@ defmodule ElixirSense.Core.MetadataBuilder do
   end
 
   defp pre(
-         {:@, [line: line, column: _column], [{:behaviour, _, [{:__aliases__, _, module_atoms}]}]} =
-           ast,
+         {:@, [line: line, column: _column],
+          [{:behaviour, _, [{:__aliases__, _, module_expression}]}]} = ast,
          state
        ) do
-    module = module_atoms |> Module.concat()
+    module = concat_module_expression(state, module_expression)
     pre_behaviour(ast, state, line, module)
   end
 
@@ -288,10 +288,10 @@ defmodule ElixirSense.Core.MetadataBuilder do
   # import with v1.2 notation
   defp pre(
          {:import, [line: line, column: _column],
-          [{{:., _, [{:__aliases__, _, prefix_atoms}, :{}]}, _, imports}]} = ast,
+          [{{:., _, [prefix_expression, :{}]}, _, imports}]} = ast,
          state
        ) do
-    imports_modules = modules_from_12_syntax(imports, prefix_atoms)
+    imports_modules = modules_from_12_syntax(state, imports, prefix_expression)
 
     pre_import(ast, state, line, imports_modules)
   end
@@ -303,12 +303,11 @@ defmodule ElixirSense.Core.MetadataBuilder do
 
   # import with options
   defp pre(
-         {:import, [line: line, column: _column], [{_, _, module_atoms = [mod | _]}, _opts]} =
+         {:import, [line: line, column: _column], [{_, _, module_expression = [_ | _]}, _opts]} =
            ast,
          state
-       )
-       when is_atom(mod) do
-    module = module_atoms |> Module.concat()
+       ) do
+    module = concat_module_expression(state, module_expression)
     pre_import(ast, state, line, module)
   end
 
@@ -321,10 +320,10 @@ defmodule ElixirSense.Core.MetadataBuilder do
   # require with v1.2 notation
   defp pre(
          {:require, [line: line, column: _column],
-          [{{:., _, [{:__aliases__, _, prefix_atoms}, :{}]}, _, requires}]} = ast,
+          [{{:., _, [prefix_expression, :{}]}, _, requires}]} = ast,
          state
        ) do
-    requires_modules = modules_from_12_syntax(requires, prefix_atoms)
+    requires_modules = modules_from_12_syntax(state, requires, prefix_expression)
 
     pre_require(ast, state, line, requires_modules)
   end
@@ -337,12 +336,12 @@ defmodule ElixirSense.Core.MetadataBuilder do
   # require with `as` option
   defp pre(
          {:require, [line: line, column: _column],
-          [{_, _, module_atoms = [mod | _]}, [as: alias_expression]]} = ast,
+          [{_, _, module_expression = [_ | _]}, [as: alias_expression]]} = ast,
          state
-       )
-       when is_atom(mod) do
-    alias_tuple = alias_tuple(Module.concat(module_atoms), alias_expression)
-    module = module_atoms |> Module.concat()
+       ) do
+    module = concat_module_expression(state, module_expression)
+    alias_tuple = alias_tuple(module, alias_expression)
+
     {_, new_state} = pre_alias(ast, state, line, alias_tuple)
     pre_require(ast, new_state, line, module)
   end
@@ -357,12 +356,11 @@ defmodule ElixirSense.Core.MetadataBuilder do
 
   # require with options
   defp pre(
-         {:require, [line: line, column: _column], [{_, _, module_atoms = [mod | _]}, _opts]} =
+         {:require, [line: line, column: _column], [{_, _, module_expression = [_ | _]}, _opts]} =
            ast,
          state
-       )
-       when is_atom(mod) do
-    module = module_atoms |> Module.concat()
+       ) do
+    module = concat_module_expression(state, module_expression)
     pre_require(ast, state, line, module)
   end
 
@@ -374,9 +372,11 @@ defmodule ElixirSense.Core.MetadataBuilder do
   # alias with v1.2 notation
   defp pre(
          {:alias, [line: line, column: _column],
-          [{{:., _, [{:__aliases__, _, prefix_atoms}, :{}]}, _, aliases}]} = ast,
+          [{{:., _, [prefix_expression, :{}]}, _, aliases}]} = ast,
          state
        ) do
+    prefix_atoms = split_module_expression(state, prefix_expression)
+
     aliases_tuples =
       aliases
       |> Enum.map(fn
@@ -389,23 +389,23 @@ defmodule ElixirSense.Core.MetadataBuilder do
 
   # alias without options
   defp pre(
-         {:alias, [line: line, column: _column], [{:__aliases__, _, module_atoms = [mod | _]}]} =
+         {:alias, [line: line, column: _column], [{:__aliases__, _, module_expression = [_ | _]}]} =
            ast,
          state
-       )
-       when is_atom(mod) do
-    alias_tuple = {Module.concat([List.last(module_atoms)]), Module.concat(module_atoms)}
+       ) do
+    module = concat_module_expression(state, module_expression)
+    alias_tuple = {Module.concat([List.last(module_expression)]), module}
     pre_alias(ast, state, line, alias_tuple)
   end
 
   # alias with `as` option
   defp pre(
          {:alias, [line: line, column: _column],
-          [{_, _, module_atoms = [mod | _]}, [as: alias_expression]]} = ast,
+          [{_, _, module_expression = [_ | _]}, [as: alias_expression]]} = ast,
          state
-       )
-       when is_atom(mod) do
-    alias_tuple = alias_tuple(Module.concat(module_atoms), alias_expression)
+       ) do
+    module = concat_module_expression(state, module_expression)
+    alias_tuple = alias_tuple(module, alias_expression)
     pre_alias(ast, state, line, alias_tuple)
   end
 
@@ -734,11 +734,19 @@ defmodule ElixirSense.Core.MetadataBuilder do
     {Module.concat(alias_atoms), module}
   end
 
-  defp modules_from_12_syntax(expressions, prefix_atoms) do
+  defp modules_from_12_syntax(state, expressions, prefix_expression) do
+    prefix_atoms = split_module_expression(state, prefix_expression)
+
     expressions
-    |> Enum.map(fn
-      {:__aliases__, _, mods} -> Module.concat(prefix_atoms ++ mods)
-      mod when is_atom(mod) -> Module.concat(prefix_atoms ++ [mod])
-    end)
+    |> Enum.map(&Module.concat(prefix_atoms ++ split_module_expression(state, &1)))
   end
+
+  defp split_module_expression(_state, {:__aliases__, _, mods}), do: mods
+  defp split_module_expression(_state, mod) when is_atom(mod), do: [mod]
+  defp split_module_expression(state, {:__MODULE__, _, nil}), do: [state |> get_current_module]
+
+  defp concat_module_expression(state, [{:__MODULE__, _, nil} | rest]),
+    do: Module.concat([state |> get_current_module] ++ rest)
+
+  defp concat_module_expression(_state, rest), do: Module.concat(rest)
 end

test/elixir_sense/core/metadata_builder_test.exs

@@ -700,6 +700,34 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
     assert get_line_aliases(state, 3) == [{User, Foo.User}, {Email, Foo.Email}]
   end
 
+  test "aliases defined with v1.2 notation __MODULE__" do
+    state =
+      """
+      defmodule MyModule do
+        alias __MODULE__.{User, Email}
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_aliases(state, 3) == [{User, MyModule.User}, {Email, MyModule.Email}]
+  end
+
+  test "aliases with __MODULE__" do
+    state =
+      """
+      defmodule MyModule do
+        alias __MODULE__.Sub
+        alias __MODULE__
+        alias __MODULE__.A.B, as: C
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_aliases(state, 5) == [{Sub, MyModule.Sub}, {C, MyModule.A.B}]
+  end
+
   test "aliases of aliases" do
     state =
       """
@@ -762,6 +790,25 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
       """
       defmodule A do
         alias Components.{Dialog, Dialog.Footer, Button, :"Elixir.Other"}
+        alias Some.{}
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_aliases(state, 4) == [
+             {Dialog, Components.Dialog},
+             {Footer, Components.Dialog.Footer},
+             {Button, Components.Button},
+             {Other, Components.Other}
+           ]
+  end
+
+  test "aliases defined with v1.2 notation with atom module" do
+    state =
+      """
+      defmodule A do
+        alias :"Elixir.Components".{Dialog, Dialog.Footer, Button, :"Elixir.Other"}
         IO.puts ""
       end
       """
@@ -821,12 +868,27 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
       """
       defmodule MyModule do
         import Foo.Bar.{User, Email, :"Elixir.Other"}
+        import Bar.{}
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_imports(state, 4) == [Foo.Bar.Other, Foo.Bar.Email, Foo.Bar.User]
+  end
+
+  test "imports defined with v1.2 notation with atom module" do
+    state =
+      """
+      defmodule MyModule do
+        import :"Elixir.Foo.Bar".{User, Email, :"Elixir.Other"}
+        import Bar.{}
         IO.puts ""
       end
       """
       |> string_to_state
 
-    assert get_line_imports(state, 3) == [Foo.Bar.Other, Foo.Bar.Email, Foo.Bar.User]
+    assert get_line_imports(state, 4) == [Foo.Bar.Other, Foo.Bar.Email, Foo.Bar.User]
   end
 
   test "imports" do
@@ -880,6 +942,19 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
     assert get_line_imports(state, 4) == [List]
   end
 
+  test "imports with __MODULE__" do
+    state =
+      """
+      defmodule OuterModule do
+        import __MODULE__.Sub
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_imports(state, 3) == [OuterModule.Sub]
+  end
+
   test "imports aliased module" do
     state =
       """
@@ -955,17 +1030,45 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
     assert get_line_requires(state, 3) == [Mod]
   end
 
+  test "requires with __MODULE__" do
+    state =
+      """
+      defmodule MyModule do
+        require __MODULE__.Sub
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_requires(state, 3) == [MyModule.Sub]
+  end
+
   test "requires with 1.2 notation" do
     state =
       """
       defmodule MyModule do
         require Mod.{Mo1, Mod2, :"Elixir.Mod3"}
+        require Foo.{}
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_requires(state, 4) == [Mod.Mod3, Mod.Mod2, Mod.Mo1]
+  end
+
+  test "requires with 1.2 notation with atom module" do
+    state =
+      """
+      defmodule MyModule do
+        require :"Elixir.Mod".{Mo1, Mod2, :"Elixir.Mod3"}
+        require Foo.{}
         IO.puts ""
       end
       """
       |> string_to_state
 
-    assert get_line_requires(state, 3) == [Mod.Mod3, Mod.Mod2, Mod.Mo1]
+    assert get_line_requires(state, 4) == [Mod.Mod3, Mod.Mod2, Mod.Mo1]
   end
 
   test "requires duplicated" do
@@ -1502,6 +1605,19 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
     assert get_line_behaviours(state, 3) == [:gen_server]
   end
 
+  test "behaviour from __MODULE__" do
+    state =
+      """
+      defmodule OuterModule do
+        @behaviour __MODULE__.Sub
+        IO.puts ""
+      end
+      """
+      |> string_to_state
+
+    assert get_line_behaviours(state, 3) == [OuterModule.Sub]
+  end
+
   test "behaviour from atom module" do
     state =
       """
@@ -1836,6 +1952,49 @@ defmodule ElixirSense.Core.MetadataBuilderTest do
            } == state.mods_funs
   end
 
+  test "use v1.2 notation" do
+    state =
+      """
+      defmodule InheritMod do
+        use ElixirSenseExample.{ExampleBehaviour}
+        use Foo.{}
+
+        IO.puts("")
+      end
+      """
+      |> string_to_state
+
+    assert get_line_behaviours(state, 5) == [ElixirSenseExample.ExampleBehaviour]
+  end
+
+  test "use v1.2 notation with atom module" do
+    state =
+      """
+      defmodule InheritMod do
+        use :"Elixir.ElixirSenseExample".{:"Elixir.ExampleBehaviour"}
+
+        IO.puts("")
+      end
+      """
+      |> string_to_state
+
+    assert get_line_behaviours(state, 4) == [ElixirSenseExample.ExampleBehaviour]
+  end
+
+  test "use with __MODULE__" do
+    state =
+      """
+      defmodule ElixirSenseExample do
+        use __MODULE__.ExampleBehaviour
+
+        IO.puts("")
+      end
+      """
+      |> string_to_state
+
+    assert get_line_behaviours(state, 4) == [ElixirSenseExample.ExampleBehaviour]
+  end
+
   test "use aliased" do
     state =
       """