provide submodule suggestions in v1.2 alias syntax (#55)

Author: lukaszsamson

lib/elixir_sense/core/source.ex

@@ -161,6 +161,21 @@ defmodule ElixirSense.Core.Source do
     end
   end
 
+  def get_v12_module_prefix(text_before) do
+    with %{"module" => module_str} <-
+           Regex.named_captures(
+             ~r/(alias|require|import|use)\s+(?<module>[^\s^\{^\}]+?)\.\{[^\}]*?$/,
+             text_before
+           ),
+         {:ok, ast} <- Code.string_to_quoted(module_str),
+         {:ok, module} <- extract_module(ast) do
+      module
+    else
+      _ ->
+        nil
+    end
+  end
+
   defp extract_module({:__aliases__, _, module_list}) do
     {:ok, Module.concat(module_list)}
   end

lib/elixir_sense/providers/suggestion.ex

@@ -166,7 +166,8 @@ defmodule ElixirSense.Providers.Suggestion do
             vars,
             attributes,
             module,
-            mods_and_funs
+            mods_and_funs,
+            text_before
           )
 
         [%{type: :hint, value: "#{hint}"} | fields ++ rest]
@@ -202,7 +203,7 @@ defmodule ElixirSense.Providers.Suggestion do
     vars = Enum.map(vars, fn v -> v.name end)
 
     %{hint: hint_suggestion, suggestions: mods_and_funcs} =
-      find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs)
+      find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs, text_before)
 
     callbacks_or_returns =
       case scope do
@@ -227,12 +228,13 @@ defmodule ElixirSense.Providers.Suggestion do
          vars,
          attributes,
          module,
-         mods_and_funs
+         mods_and_funs,
+         text_before
        ) do
     vars = Enum.map(vars, fn v -> v.name end)
 
     %{hint: hint_suggestion, suggestions: mods_and_funcs} =
-      find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs)
+      find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs, text_before)
 
     [hint_suggestion]
     |> Kernel.++(find_attributes(attributes, hint))
@@ -277,20 +279,42 @@ defmodule ElixirSense.Providers.Suggestion do
     end
   end
 
-  @spec find_hint_mods_funcs(String.t(), [module], [{module, module}], module, %{}) :: %{
-          hint: hint,
-          suggestions: [mod | func]
-        }
-  defp find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs) do
+  @spec find_hint_mods_funcs(String.t(), [module], [{module, module}], module, %{}, String.t()) ::
+          %{
+            hint: hint,
+            suggestions: [mod | func]
+          }
+  defp find_hint_mods_funcs(hint, imports, aliases, module, mods_and_funs, text_before) do
     env = %Complete.Env{
       aliases: aliases,
       scope_module: module,
       imports: imports,
       mods_and_funs: mods_and_funs
     }
 
-    {hint_suggestion, suggestions} = Complete.run(hint, env)
-    %{hint: hint_suggestion, suggestions: suggestions}
+    {hint, prefix} =
+      case Source.get_v12_module_prefix(text_before) do
+        nil ->
+          {hint, ""}
+
+        module ->
+          # v1.2 alias syntax detected
+          # prepend module prefix before running completion
+          prefix = inspect(module) <> "."
+          {prefix <> hint, prefix}
+      end
+
+    {%{type: :hint, value: prefixed_value}, suggestions} = Complete.run(hint, env)
+
+    # drop module prefix from hint if added
+    value =
+      if prefix != "" do
+        prefixed_value |> String.replace_leading(prefix, "")
+      else
+        prefixed_value
+      end
+
+    %{hint: %{type: :hint, value: value}, suggestions: suggestions}
   end
 
   @spec find_vars([String.t()], String.t()) :: [variable]

test/elixir_sense/core/source_test.exs

@@ -561,4 +561,98 @@ defmodule ElixirSense.Core.SourceTest do
       assert which_struct(text_before(code, 5, 7)) == {Mod, [:field1]}
     end
   end
+
+  describe "alias syntax v1.2" do
+    test "single level" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias Mod.{
+      """
+
+      assert get_v12_module_prefix(code) == Mod
+    end
+
+    test "single level with submodule" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          require Mod.{Su
+      """
+
+      assert get_v12_module_prefix(code) == Mod
+    end
+
+    test "single level with submodules" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          use Mod.{Su.Bmod, Other
+      """
+
+      assert get_v12_module_prefix(code) == Mod
+    end
+
+    test "multi level with submodules" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          import Mod.Sub.{
+      """
+
+      assert get_v12_module_prefix(code) == Mod.Sub
+    end
+
+    test "__MODULE__ special form level with submodules" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias __MODULE__.{
+      """
+
+      assert get_v12_module_prefix(code) == :__MODULE__
+    end
+
+    test "atom module special form level with submodules" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias :"Elixir.Mod".{
+      """
+
+      assert get_v12_module_prefix(code) == Mod
+    end
+
+    test "nil when closed" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias Mod.{}
+      """
+
+      assert get_v12_module_prefix(code) == nil
+    end
+
+    test "nil when not on last line" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias Mod.{A, B}
+          alias C
+      """
+
+      assert get_v12_module_prefix(code) == nil
+    end
+
+    test "multiline" do
+      code = """
+      defmodule MyMod do
+        def my_func(par1) do
+          alias Mod.{A,
+            B
+      """
+
+      assert get_v12_module_prefix(code) == Mod
+    end
+  end
 end

test/elixir_sense/suggestions_test.exs

@@ -1166,6 +1166,36 @@ defmodule ElixirSense.SuggestionsTest do
     assert Enum.any?(list, fn %{type: type} -> type == :field end) == false
   end
 
+  test "suggest modules to alias" do
+    buffer = """
+    defmodule MyModule do
+      alias Str
+    end
+    """
+
+    list =
+      ElixirSense.suggestions(buffer, 2, 12)
+      |> Enum.filter(fn s -> s.type == :module end)
+
+    assert [
+             %{name: "Stream"},
+             %{name: "String"},
+             %{name: "StringIO"}
+           ] = list
+  end
+
+  test "suggest modules to alias v1.2 syntax" do
+    buffer = """
+    defmodule MyModule do
+      alias Stream.{Re
+    end
+    """
+
+    list = ElixirSense.suggestions(buffer, 2, 19)
+
+    assert [%{type: :hint, value: "Reducers"}, %{name: "Reducers", type: :module}] = list
+  end
+
   describe "suggestion for param options" do
     test "suggest more than one option" do
       buffer = "Local.func_with_options("