Multialias in hover, definition and references

Fixes #1075

Author: lukaszsamson

apps/language_server/lib/language_server/providers/definition/locator.ex

@@ -118,6 +118,49 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
           }
         end
 
+      {{:atom, alias}, nil} ->
+        # Handle multialias syntax
+        text_before =
+          Source.text_before(metadata.source, context.end |> elem(0), context.end |> elem(1))
+
+        case Code.Fragment.container_cursor_to_quoted(text_before) do
+          {:ok, quoted} ->
+            case Macro.path(quoted, fn
+                   {:., _, [{:__aliases__, _, _}, :{}]} -> true
+                   _ -> false
+                 end) do
+              [{:., _, [{:__aliases__, _, outer_alias}, :{}]} | _] ->
+                # Combine outer alias with the one under cursor
+                expanded = Module.concat(outer_alias ++ [alias])
+
+                find_function_or_module(
+                  {{:atom, expanded}, nil},
+                  context,
+                  env,
+                  metadata,
+                  binding_env
+                )
+
+              _ ->
+                find_function_or_module(
+                  {{:atom, alias}, nil},
+                  context,
+                  env,
+                  metadata,
+                  binding_env
+                )
+            end
+
+          _ ->
+            find_function_or_module(
+              {{:atom, alias}, nil},
+              context,
+              env,
+              metadata,
+              binding_env
+            )
+        end
+
       {module, function} ->
         find_function_or_module(
           {module, function},

apps/language_server/lib/language_server/providers/hover/docs.ex

@@ -19,6 +19,7 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
   alias ElixirSense.Core.State.{ModFunInfo, SpecInfo}
   alias ElixirSense.Core.TypeInfo
   alias ElixirSense.Core.Parser
+  alias ElixirSense.Core.Source
 
   @type markdown :: String.t()
 
@@ -150,6 +151,30 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
           )
         end
 
+      {{:atom, alias}, nil} ->
+        # Handle multialias syntax
+        text_before =
+          Source.text_before(metadata.source, context.end |> elem(0), context.end |> elem(1))
+
+        case Code.Fragment.container_cursor_to_quoted(text_before) do
+          {:ok, quoted} ->
+            case Macro.path(quoted, fn
+                   {:., _, [{:__aliases__, _, _}, :{}]} -> true
+                   _ -> false
+                 end) do
+              [{:., _, [{:__aliases__, _, outer_alias}, :{}]} | _] ->
+                # Combine outer alias with the one under cursor
+                expanded = Module.concat(outer_alias ++ [alias])
+                mod_fun_docs({{:atom, expanded}, nil}, context, binding_env, env, metadata)
+
+              _ ->
+                mod_fun_docs({{:atom, alias}, nil}, context, binding_env, env, metadata)
+            end
+
+          _ ->
+            mod_fun_docs({{:atom, alias}, nil}, context, binding_env, env, metadata)
+        end
+
       _ ->
         mod_fun_docs(
           type,

apps/language_server/lib/language_server/providers/references/locator.ex

@@ -18,6 +18,7 @@ defmodule ElixirLS.LanguageServer.Providers.References.Locator do
   alias ElixirSense.Core.State.VarInfo
   alias ElixirSense.Core.SurroundContext
   alias ElixirSense.Core.Parser
+  alias ElixirSense.Core.Source
 
   def references(code, line, column, trace, options \\ []) do
     case NormalizedCode.Fragment.surround_context(code, {line, column}) do
@@ -210,6 +211,30 @@ defmodule ElixirLS.LanguageServer.Providers.References.Locator do
           []
         end
 
+      {{:atom, alias}, nil} ->
+        # Handle multialias syntax
+        text_before =
+          Source.text_before(metadata.source, context.end |> elem(0), context.end |> elem(1))
+
+        case Code.Fragment.container_cursor_to_quoted(text_before) do
+          {:ok, quoted} ->
+            case Macro.path(quoted, fn
+                   {:., _, [{:__aliases__, _, _}, :{}]} -> true
+                   _ -> false
+                 end) do
+              [{:., _, [{:__aliases__, _, outer_alias}, :{}]} | _] ->
+                # Combine outer alias with the one under cursor
+                expanded = Module.concat(outer_alias ++ [alias])
+                refs_for_mod_fun.({{:atom, expanded}, nil})
+
+              _ ->
+                refs_for_mod_fun.({{:atom, alias}, nil})
+            end
+
+          _ ->
+            refs_for_mod_fun.({{:atom, alias}, nil})
+        end
+
       {mod, function} ->
         refs_for_mod_fun.({mod, function})
     end

apps/language_server/test/providers/definition/locator_test.exs

@@ -308,6 +308,42 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.LocatorTest do
     assert read_range(location) =~ "@moduledoc \"example module\""
   end
 
+  test "find definition on module in multialias" do
+    buffer = """
+    defmodule Foo.Bar do
+    end
+
+    defmodule Foo.Baz.Boom do
+    end
+
+    defmodule MyModule do
+      alias Foo.{Bar, Baz.Boom}
+      alias Foo, as: X
+      require X.{Bar, Baz.Boom}
+      alias Foo, as: Y
+      import Elixir.Foo.{Bar, Baz.Boom}
+    end
+    """
+
+    assert %Location{type: :module, file: nil, line: 1, column: 1} =
+             Locator.definition(buffer, 8, 15)
+
+    assert %Location{type: :module, file: nil, line: 4, column: 1} =
+             Locator.definition(buffer, 8, 20)
+
+    assert %Location{type: :module, file: nil, line: 1, column: 1} =
+             Locator.definition(buffer, 10, 15)
+
+    assert %Location{type: :module, file: nil, line: 4, column: 1} =
+             Locator.definition(buffer, 10, 20)
+
+    assert %Location{type: :module, file: nil, line: 1, column: 1} =
+             Locator.definition(buffer, 12, 23)
+
+    assert %Location{type: :module, file: nil, line: 4, column: 1} =
+             Locator.definition(buffer, 12, 28)
+  end
+
   test "find definition for the correct arity of function - on fn call" do
     buffer = """
     defmodule MyModule do

apps/language_server/test/providers/hover/docs_test.exs

@@ -214,6 +214,92 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do
 
       refute Docs.docs(buffer, 2, 11)
     end
+
+    test "retrieve documentation from modules in multialias" do
+      buffer = """
+      defmodule Foo.Bar do
+        @moduledoc "Bar module doc"
+      end
+
+      defmodule Foo.Baz.Boom do
+        @moduledoc "Boom module doc"
+      end
+
+      defmodule MyModule do
+        alias Foo.{Bar, Baz.Boom}
+        alias Foo, as: X
+        require X.{Bar, Baz.Boom}
+        alias Foo, as: Y
+        import Elixir.Foo.{Bar, Baz.Boom}
+      end
+      """
+
+      # Test hover on Bar in multialias
+      %{
+        docs: [bar_doc]
+      } = Docs.docs(buffer, 10, 15)
+
+      assert %{
+               module: Foo.Bar,
+               docs: "Bar module doc",
+               kind: :module
+             } = bar_doc
+
+      # Test hover on Boom in multialias
+      %{
+        docs: [boom_doc]
+      } = Docs.docs(buffer, 10, 20)
+
+      assert %{
+               module: Foo.Baz.Boom,
+               docs: "Boom module doc",
+               kind: :module
+             } = boom_doc
+
+      # Test hover on Bar in require
+      %{
+        docs: [require_bar_doc]
+      } = Docs.docs(buffer, 12, 15)
+
+      assert %{
+               module: Foo.Bar,
+               docs: "Bar module doc",
+               kind: :module
+             } = require_bar_doc
+
+      # Test hover on Boom in require
+      %{
+        docs: [require_boom_doc]
+      } = Docs.docs(buffer, 12, 20)
+
+      assert %{
+               module: Foo.Baz.Boom,
+               docs: "Boom module doc",
+               kind: :module
+             } = require_boom_doc
+
+      # Test hover on Bar in import
+      %{
+        docs: [import_bar_doc]
+      } = Docs.docs(buffer, 14, 23)
+
+      assert %{
+               module: Foo.Bar,
+               docs: "Bar module doc",
+               kind: :module
+             } = import_bar_doc
+
+      # Test hover on Boom in import
+      %{
+        docs: [import_boom_doc]
+      } = Docs.docs(buffer, 14, 28)
+
+      assert %{
+               module: Foo.Baz.Boom,
+               docs: "Boom module doc",
+               kind: :module
+             } = import_boom_doc
+    end
   end
 
   describe "functions and macros" do

apps/language_server/test/providers/references/locator_test.exs

@@ -2200,6 +2200,81 @@ defmodule ElixirLS.LanguageServer.Providers.References.LocatorTest do
                }
              ] = references
     end
+
+    test "find references in multialias", %{trace: trace} do
+      buffer = """
+      defmodule Foo.Bar do
+        def hello(), do: :ok
+      end
+
+      defmodule Foo.Baz.Boom do
+        def world(), do: :ok
+      end
+
+      defmodule MyModule do
+        alias Foo.{Bar, Baz.Boom}
+        
+        def process() do
+          Bar.hello()
+          Boom.world()
+        end
+      end
+      """
+
+      # Test references for Bar in multialias
+      references = Locator.references(buffer, 10, 15, trace)
+
+      assert [
+               %{
+                 range: %{
+                   start: %{line: 10, column: 3},
+                   end: %{line: 10, column: 3}
+                 },
+                 uri: nil
+               },
+               %{
+                 range: %{
+                   start: %{line: 13, column: 5},
+                   end: %{line: 13, column: 5}
+                 },
+                 uri: nil
+               },
+               %{
+                 range: %{
+                   start: %{line: 13, column: 9},
+                   end: %{line: 13, column: 14}
+                 },
+                 uri: nil
+               }
+             ] = references
+
+      # Test references for Boom in multialias
+      references = Locator.references(buffer, 10, 20, trace)
+
+      assert [
+               %{
+                 range: %{
+                   start: %{line: 10, column: 3},
+                   end: %{line: 10, column: 3}
+                 },
+                 uri: nil
+               },
+               %{
+                 range: %{
+                   start: %{line: 14, column: 5},
+                   end: %{line: 14, column: 5}
+                 },
+                 uri: nil
+               },
+               %{
+                 range: %{
+                   start: %{line: 14, column: 10},
+                   end: %{line: 14, column: 15}
+                 },
+                 uri: nil
+               }
+             ] = references
+    end
   end
 
   test "local vs remote references" do