diff --git a/lib/next_ls.ex b/lib/next_ls.ex
index f77c6440..c0d86a44 100644
--- a/lib/next_ls.ex
+++ b/lib/next_ls.ex
@@ -24,6 +24,7 @@ defmodule NextLS do
   alias GenLSP.Requests.TextDocumentFormatting
   alias GenLSP.Requests.TextDocumentHover
   alias GenLSP.Requests.TextDocumentReferences
+  alias GenLSP.Requests.TextDocumentSignatureHelp
   alias GenLSP.Requests.WorkspaceApplyEdit
   alias GenLSP.Requests.WorkspaceSymbol
   alias GenLSP.Structures.ApplyWorkspaceEditParams
@@ -41,6 +42,8 @@ defmodule NextLS do
   alias GenLSP.Structures.Range
   alias GenLSP.Structures.SaveOptions
   alias GenLSP.Structures.ServerCapabilities
+  alias GenLSP.Structures.SignatureHelp
+  alias GenLSP.Structures.SignatureHelpParams
   alias GenLSP.Structures.SymbolInformation
   alias GenLSP.Structures.TextDocumentIdentifier
   alias GenLSP.Structures.TextDocumentItem
@@ -53,6 +56,7 @@ defmodule NextLS do
   alias NextLS.DiagnosticCache
   alias NextLS.Progress
   alias NextLS.Runtime
+  alias NextLS.SignatureHelp
 
   require NextLS.Runtime
 
@@ -165,6 +169,9 @@ defmodule NextLS do
              "alias-refactor"
            ]
          },
+         signature_help_provider: %GenLSP.Structures.SignatureHelpOptions{
+           trigger_characters: ["(", ","]
+         },
          hover_provider: true,
          workspace_symbol_provider: true,
          document_symbol_provider: true,
@@ -810,6 +817,36 @@ defmodule NextLS do
       {:reply, nil, lsp}
   end
 
+  def handle_request(
+        %TextDocumentSignatureHelp{params: %SignatureHelpParams{text_document: %{uri: uri}, position: position}},
+        lsp
+      ) do
+    text = Enum.join(lsp.assigns.documents[uri], "\n")
+
+    signature_help =
+      case SignatureHelp.fetch(text, {position.line + 1, position.character + 1}) do
+        {:ok, {mod, name, param_index}} ->
+          docs =
+            dispatch(lsp.assigns.registry, :runtimes, fn entries ->
+              [result] =
+                for {runtime, %{uri: wuri}} <- entries, String.starts_with?(uri, wuri) do
+                  Runtime.call(runtime, {Code, :fetch_docs, [mod]})
+                end
+
+              result
+            end)
+
+          docs
+          |> SignatureHelp.format(name, param_index)
+          |> List.first()
+
+        {:error, :not_found} ->
+          nil
+      end
+
+    {:reply, signature_help, lsp}
+  end
+
   def handle_request(%Shutdown{}, lsp) do
     {:reply, nil, assign(lsp, exit_code: 0)}
   end
diff --git a/lib/next_ls/helpers/ast_helpers.ex b/lib/next_ls/helpers/ast_helpers.ex
index 7b5b9981..73325593 100644
--- a/lib/next_ls/helpers/ast_helpers.ex
+++ b/lib/next_ls/helpers/ast_helpers.ex
@@ -216,4 +216,52 @@ defmodule NextLS.ASTHelpers do
 
     top(zipper, acc, callback)
   end
+
+  defmodule Function do
+    @moduledoc false
+
+    def find_remote_function_call_within(ast, {line, column}) do
+      position = [line: line, column: column]
+
+      result =
+        ast
+        |> Zipper.zip()
+        |> Zipper.find(fn
+          {:|>, _, [_, {{:., _, _}, _metadata, _} = func_node]} ->
+            inside?(func_node, position)
+
+          {{:., _, _}, _metadata, _} = node ->
+            inside?(node, position)
+
+          _ ->
+            false
+        end)
+
+      if result do
+        {:ok, Zipper.node(result)}
+      else
+        {:error, :not_found}
+      end
+    end
+
+    def find_params_index(ast, {line, column}) do
+      ast
+      |> Sourceror.get_args()
+      |> Enum.map(&Sourceror.get_meta/1)
+      |> Enum.find_index(fn meta ->
+        if meta[:closing] do
+          line <= meta[:closing][:line] and line >= meta[:line]
+        else
+          meta[:line] == line and column <= meta[:column]
+        end
+      end)
+    end
+
+    defp inside?(node, position) do
+      range = Sourceror.get_range(node)
+
+      Sourceror.compare_positions(range.start, position) == :lt &&
+        Sourceror.compare_positions(range.end, position) == :gt
+    end
+  end
 end
diff --git a/lib/next_ls/signature_help.ex b/lib/next_ls/signature_help.ex
new file mode 100644
index 00000000..838cee78
--- /dev/null
+++ b/lib/next_ls/signature_help.ex
@@ -0,0 +1,83 @@
+defmodule NextLS.SignatureHelp do
+  @moduledoc false
+
+  alias GenLSP.Enumerations.MarkupKind
+  alias GenLSP.Structures.MarkupContent
+  alias GenLSP.Structures.ParameterInformation
+  alias GenLSP.Structures.SignatureHelp
+  alias GenLSP.Structures.SignatureInformation
+  alias NextLS.ASTHelpers
+
+  def fetch(text, position) do
+    ast =
+      text
+      |> Spitfire.parse(literal_encoder: &{:ok, {:__literal__, &2, [&1]}})
+      |> then(fn
+        {:ok, ast} -> ast
+        {:error, ast, _} -> ast
+      end)
+
+    with {:ok, result} <- ASTHelpers.Function.find_remote_function_call_within(ast, position) do
+      case result do
+        {:|>, _, [_, {{:., _, [{:__aliases__, _, modules}, name]}, _, _} = node]} ->
+          param_index = ASTHelpers.Function.find_params_index(node, position)
+
+          if param_index do
+            {:ok, {Module.concat(modules), name, param_index + 1}}
+          else
+            {:ok, {Module.concat(modules), name, nil}}
+          end
+
+        {{:., _, [{:__aliases__, _, modules}, name]}, _, _} = node ->
+          param_index = ASTHelpers.Function.find_params_index(node, position)
+
+          {:ok, {Module.concat(modules), name, param_index}}
+
+        _otherwise ->
+          {:error, :not_found}
+      end
+    end
+  end
+
+  def format({:ok, {:docs_v1, _, _lang, content_type, _, _, docs}}, func_name, param_index) do
+    for {{_, name, _arity}, _, [signature], fdoc, _} <- docs, name == func_name do
+      params_info =
+        signature
+        |> Spitfire.parse!()
+        |> Sourceror.get_args()
+        |> Enum.map(fn {name, _, _} ->
+          %ParameterInformation{
+            label: Atom.to_string(name)
+          }
+        end)
+
+      %SignatureHelp{
+        signatures: [
+          %SignatureInformation{
+            label: signature,
+            parameters: params_info,
+            documentation: maybe_doc(content_type, fdoc),
+            active_parameter: param_index
+          }
+        ]
+      }
+    end
+  end
+
+  def format({:ok, {:error, :module_not_found}}, _func_name, _param_index) do
+    []
+  end
+
+  def format({:error, :not_ready}, _func_name, _param_index) do
+    []
+  end
+
+  defp maybe_doc(content_type, %{"en" => fdoc}) do
+    %MarkupContent{
+      kind: MarkupKind.markdown(),
+      value: NextLS.Docs.to_markdown(content_type, fdoc)
+    }
+  end
+
+  defp maybe_doc(_content_type, _fdoc), do: nil
+end
diff --git a/test/next_ls/docs_test.exs b/test/next_ls/docs_test.exs
deleted file mode 100644
index 75ac8782..00000000
--- a/test/next_ls/docs_test.exs
+++ /dev/null
@@ -1,264 +0,0 @@
-defmodule NextLS.DocsTest do
-  use ExUnit.Case, async: true
-
-  alias NextLS.Docs
-
-  describe "converts erlang html format to markdown" do
-    test "some divs and p and code" do
-      html = [
-        {:p, [],
-         [
-           "Suspends the process calling this function for ",
-           {:code, [], ["Time"]},
-           " milliseconds and then returns ",
-           {:code, [], ["ok"]},
-           ", or suspends the process forever if ",
-           {:code, [], ["Time"]},
-           " is the atom ",
-           {:code, [], ["infinity"]},
-           ". Naturally, this function does ",
-           {:em, [], ["not"]},
-           " return immediately."
-         ]},
-        {:div, [class: "note"],
-         [
-           {:p, [],
-            [
-              "Before OTP 25, ",
-              {:code, [], ["timer:sleep/1"]},
-              " did not accept integer timeout values greater than ",
-              {:code, [], ["16#ffffffff"]},
-              ", that is, ",
-              {:code, [], ["2^32-1"]},
-              ". Since OTP 25, arbitrarily high integer values are accepted."
-            ]}
-         ]}
-      ]
-
-      actual = Docs.to_markdown("application/erlang+html", html)
-
-      assert actual ==
-               String.trim("""
-               Suspends the process calling this function for `Time` milliseconds and then returns `ok`, or suspends the process forever if `Time` is the atom `infinity`. Naturally, this function does _not_ return immediately.
-
-               > Before OTP 25, `timer:sleep/1` did not accept integer timeout values greater than `16#ffffffff`, that is, `2^32-1`. Since OTP 25, arbitrarily high integer values are accepted.
-               """)
-    end
-
-    test "some p and a and code" do
-      html = [
-        {:p, [],
-         [
-           "The same as ",
-           {:a,
-            [
-              href: "erts:erlang#atom_to_binary/2",
-              rel: "https://erlang.org/doc/link/seemfa"
-            ], [{:code, [], ["atom_to_binary"]}, " "]},
-           {:code, [], ["(Atom, utf8)"]},
-           "."
-         ]}
-      ]
-
-      actual = Docs.to_markdown("application/erlang+html", html)
-
-      assert actual ==
-               String.trim("""
-               The same as [`atom_to_binary`](erts:erlang#atom_to_binary/2) `(Atom, utf8)`.
-               """)
-    end
-
-    test "some code" do
-      html = [
-        {:p, [],
-         [
-           "Extracts the part of the binary described by ",
-           {:code, [], ["PosLen"]},
-           "."
-         ]},
-        {:p, [], ["Negative length can be used to extract bytes at the end of a binary, for example:"]},
-        {:pre, [],
-         [
-           {:code, [],
-            ["1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.\n2> binary_part(Bin,{byte_size(Bin), -5}).\n<<6,7,8,9,10>>"]}
-         ]},
-        {:p, [],
-         [
-           "Failure: ",
-           {:code, [], ["badarg"]},
-           " if ",
-           {:code, [], ["PosLen"]},
-           " in any way references outside the binary."
-         ]},
-        {:p, [], [{:code, [], ["Start"]}, " is zero-based, that is:"]},
-        {:pre, [], [{:code, [], ["1> Bin = <<1,2,3>>\n2> binary_part(Bin,{0,2}).\n<<1,2>>"]}]},
-        {:p, [],
-         [
-           "For details about the ",
-           {:code, [], ["PosLen"]},
-           " semantics, see ",
-           {:a, [href: "stdlib:binary", rel: "https://erlang.org/doc/link/seeerl"], [{:code, [], ["binary(3)"]}]},
-           "."
-         ]},
-        {:p, [], ["Allowed in guard tests."]}
-      ]
-
-      actual = Docs.to_markdown("application/erlang+html", html)
-
-      assert actual ==
-               String.trim("""
-               Extracts the part of the binary described by `PosLen`.
-
-               Negative length can be used to extract bytes at the end of a binary, for example:
-
-               ```erlang
-               1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
-               2> binary_part(Bin,{byte_size(Bin), -5}).
-               <<6,7,8,9,10>>
-               ```
-
-               Failure: `badarg` if `PosLen` in any way references outside the binary.
-
-               `Start` is zero-based, that is:
-
-               ```erlang
-               1> Bin = <<1,2,3>>
-               2> binary_part(Bin,{0,2}).
-               <<1,2>>
-               ```
-
-               For details about the `PosLen` semantics, see [`binary(3)`](stdlib:binary).
-
-               Allowed in guard tests.
-               """)
-    end
-
-    test "ul and li" do
-      html = [
-        {:ul, [],
-         [
-           {:li, [],
-            [
-              {:p, [],
-               [
-                 "Find an arbitrary ",
-                 {:a,
-                  [
-                    href: "stdlib:digraph#simple_path",
-                    rel: "https://erlang.org/doc/link/seeerl"
-                  ], ["simple path"]},
-                 " v[1], v[2], ..., v[k] from ",
-                 {:code, [], ["V1"]},
-                 " to ",
-                 {:code, [], ["V2"]},
-                 " in ",
-                 {:code, [], ["G"]},
-                 "."
-               ]}
-            ]},
-           {:li, [],
-            [
-              {:p, [],
-               [
-                 "Remove all edges of ",
-                 {:code, [], ["G"]},
-                 " ",
-                 {:a,
-                  [
-                    href: "stdlib:digraph#emanate",
-                    rel: "https://erlang.org/doc/link/seeerl"
-                  ], ["emanating"]},
-                 " from v[i] and ",
-                 {:a,
-                  [
-                    href: "stdlib:digraph#incident",
-                    rel: "https://erlang.org/doc/link/seeerl"
-                  ], ["incident"]},
-                 " to v[i+1] for 1 <= i < k (including multiple edges)."
-               ]}
-            ]},
-           {:li, [],
-            [
-              {:p, [],
-               [
-                 "Repeat until there is no path between ",
-                 {:code, [], ["V1"]},
-                 " and ",
-                 {:code, [], ["V2"]},
-                 "."
-               ]}
-            ]}
-         ]}
-      ]
-
-      actual = Docs.to_markdown("application/erlang+html", html)
-
-      assert String.trim(actual) ==
-               String.trim("""
-               * Find an arbitrary [simple path](stdlib:digraph#simple_path) v[1], v[2], ..., v[k] from `V1` to `V2` in `G`.
-               * Remove all edges of `G` [emanating](stdlib:digraph#emanate) from v[i] and [incident](stdlib:digraph#incident) to v[i+1] for 1 <= i < k (including multiple edges).
-               * Repeat until there is no path between `V1` and `V2`.
-               """)
-    end
-
-    test "dl, dt, and dd" do
-      html = [
-        {:dl, [],
-         [
-           {:dt, [], [{:code, [], ["root"]}]},
-           {:dd, [],
-            [
-              {:p, [], ["The installation directory of Erlang/OTP, ", {:code, [], ["$ROOT"]}, ":"]},
-              {:pre, [],
-               [
-                 {:code, [],
-                  ["2> init:get_argument(root).\n{ok,[[\"/usr/local/otp/releases/otp_beam_solaris8_r10b_patched\"]]}"]}
-               ]}
-            ]},
-           {:dt, [], [{:code, [], ["progname"]}]},
-           {:dd, [],
-            [
-              {:p, [], ["The name of the program which started Erlang:"]},
-              {:pre, [], [{:code, [], ["3> init:get_argument(progname).\n{ok,[[\"erl\"]]}"]}]}
-            ]},
-           {:dt, [], [{:a, [id: "home"], []}, {:code, [], ["home"]}]},
-           {:dd, [],
-            [
-              {:p, [], ["The home directory (on Unix, the value of $HOME):"]},
-              {:pre, [], [{:code, [], ["4> init:get_argument(home).\n{ok,[[\"/home/harry\"]]}"]}]}
-            ]}
-         ]},
-        {:p, [], ["Returns ", {:code, [], ["error"]}, " if no value is associated with ", {:code, [], ["Flag"]}, "."]}
-      ]
-
-      actual = Docs.to_markdown("application/erlang+html", html)
-
-      assert String.trim(actual) ==
-               String.trim("""
-               * `root`
-               The installation directory of Erlang/OTP, `$ROOT`:
-
-               ```erlang
-               2> init:get_argument(root).
-               {ok,[[\"/usr/local/otp/releases/otp_beam_solaris8_r10b_patched\"]]}
-               ```
-               * `progname`
-               The name of the program which started Erlang:
-
-               ```erlang
-               3> init:get_argument(progname).
-               {ok,[[\"erl\"]]}
-               ```
-               * []()`home`
-               The home directory (on Unix, the value of $HOME):
-
-               ```erlang
-               4> init:get_argument(home).
-               {ok,[[\"/home/harry\"]]}
-               ```
-
-               Returns `error` if no value is associated with `Flag`.
-               """)
-    end
-  end
-end
diff --git a/test/next_ls/signature_help_test.exs b/test/next_ls/signature_help_test.exs
new file mode 100644
index 00000000..1b860c80
--- /dev/null
+++ b/test/next_ls/signature_help_test.exs
@@ -0,0 +1,335 @@
+defmodule NextLS.SignatureHelpTest do
+  use ExUnit.Case, async: true
+
+  import GenLSP.Test
+  import NextLS.Support.Utils
+
+  @moduletag :tmp_dir
+
+  describe "function" do
+    @describetag root_paths: ["my_proj"]
+    setup %{tmp_dir: tmp_dir} do
+      File.mkdir_p!(Path.join(tmp_dir, "my_proj/lib"))
+      File.mkdir_p!(Path.join(tmp_dir, "my_proj/lib/remote"))
+      File.write!(Path.join(tmp_dir, "my_proj/mix.exs"), mix_exs())
+      [cwd: tmp_dir]
+    end
+
+    setup %{cwd: cwd} do
+      remote = Path.join(cwd, "my_proj/lib/remote.ex")
+
+      File.write!(remote, """
+      defmodule Remote do
+        @doc "doc example"
+        def bang!(bang) do
+          bang
+        end
+
+        def bangs!(bang1, _bang2) do
+          bang1
+        end
+      end
+      """)
+
+      nested_alias = Path.join(cwd, "my_proj/lib/remote/nested_alias.ex")
+
+      File.write!(nested_alias, """
+      defmodule Remote.NestedAlias do
+        def bang!(bang) do
+          bang
+        end
+      end
+      """)
+
+      imported = Path.join(cwd, "my_proj/lib/imported.ex")
+
+      File.write!(imported, """
+      defmodule Imported do
+        def boom([] = boom1, _boom2) do
+          boom1
+        end
+      end
+      """)
+
+      [imported: imported, remote: remote, nested_alias: nested_alias]
+    end
+
+    setup :with_lsp
+
+    setup context do
+      assert :ok == notify(context.client, %{method: "initialized", jsonrpc: "2.0", params: %{}})
+      assert_is_ready(context, "my_proj")
+      assert_compiled(context, "my_proj")
+      assert_notification "$/progress", %{"value" => %{"kind" => "end", "message" => "Finished indexing!"}}
+    end
+
+    test "get signature help", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          Remote.bang!("bang1")
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 2, character: 15},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "bang"}
+            ],
+            "label" => "bang!(bang)",
+            "documentation" => %{
+              "kind" => "markdown",
+              "value" => "doc example"
+            },
+            "activeParameter" => 0
+          }
+        ]
+      }
+    end
+
+    test "get signature help with multiple params", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          Remote.bangs!("bang1", "bang2")
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 2, character: 15},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "bang1"},
+              %{"label" => "bang2"}
+            ],
+            "label" => "bangs!(bang1, bang2)",
+            "activeParameter" => 0
+          }
+        ]
+      }
+    end
+
+    test "get signature help with multiple params and active parameter 1", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          Remote.bangs!("bang1", "bang2")
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 2, character: 22},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "bang1"},
+              %{"label" => "bang2"}
+            ],
+            "label" => "bangs!(bang1, bang2)",
+            "activeParameter" => 1
+          }
+        ]
+      }
+    end
+
+    test "get signature help with parameters on multiple lines", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          Remote.bangs!(
+            "bang1",
+            "bang2"
+          )
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 4, character: 6},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "bang1"},
+              %{"label" => "bang2"}
+            ],
+            "label" => "bangs!(bang1, bang2)",
+            "activeParameter" => 1
+          }
+        ]
+      }
+    end
+
+    test "get signature help with pipe", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          "bang1" |> Remote.bangs!("bang2")
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 2, character: 25},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "bang1"},
+              %{"label" => "bang2"}
+            ],
+            "label" => "bangs!(bang1, bang2)",
+            "activeParameter" => 1
+          }
+        ]
+      }
+    end
+
+    test "get signature help with multiple pipe", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          ["bang", "bang"]
+          |> Enum.map(fn name -> "super" <> name end)
+          |> Remote.bangs!()
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 3, character: 25},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "enumerable"},
+              %{"label" => "fun"}
+            ],
+            "label" => "map(enumerable, fun)",
+            "activeParameter" => 1
+          }
+        ]
+      }
+    end
+
+    test "get signature help with param function on multiple lines", %{client: client, cwd: cwd} do
+      did_open(client, Path.join(cwd, "my_proj/lib/bar.ex"), """
+      defmodule Bar do
+        def run do
+          Enum.map([1, 2, 3], fn n ->
+            n + 1
+          end)
+        end
+      end
+      """)
+
+      uri = "file://#{cwd}/my_proj/lib/bar.ex"
+
+      did_change(client, uri)
+
+      request(client, %{
+        method: "textDocument/signatureHelp",
+        id: 4,
+        jsonrpc: "2.0",
+        params: %{
+          position: %{line: 3, character: 3},
+          textDocument: %{uri: uri}
+        }
+      })
+
+      assert_result 4, %{
+        "signatures" => [
+          %{
+            "parameters" => [
+              %{"label" => "enumerable"},
+              %{"label" => "fun"}
+            ],
+            "label" => "map(enumerable, fun)",
+            "activeParameter" => 1
+          }
+        ]
+      }
+    end
+  end
+end
diff --git a/test/next_ls_test.exs b/test/next_ls_test.exs
index 23769f07..8a168df3 100644
--- a/test/next_ls_test.exs
+++ b/test/next_ls_test.exs
@@ -77,20 +77,20 @@ defmodule NextLSTest do
 
     assert :ok ==
              request(client, %{
-               method: "textDocument/signatureHelp",
+               method: "textDocument/typeDefinition",
                id: id,
                jsonrpc: "2.0",
                params: %{position: %{line: 0, character: 0}, textDocument: %{uri: ""}}
              })
 
     assert_notification "window/logMessage", %{
-      "message" => "[Next LS] Method Not Found: textDocument/signatureHelp",
+      "message" => "[Next LS] Method Not Found: textDocument/typeDefinition",
       "type" => 2
     }
 
     assert_error ^id, %{
       "code" => -32_601,
-      "message" => "Method Not Found: textDocument/signatureHelp"
+      "message" => "Method Not Found: textDocument/typeDefinition"
     }
   end
 
diff --git a/test/support/utils.ex b/test/support/utils.ex
index 882026ef..b4ab007b 100644
--- a/test/support/utils.ex
+++ b/test/support/utils.ex
@@ -181,6 +181,24 @@ defmodule NextLS.Support.Utils do
     end
   end
 
+  defmacro did_change(client, uri) do
+    quote do
+      assert :ok ==
+               notify(unquote(client), %{
+                 method: "workspace/didChangeWatchedFiles",
+                 jsonrpc: "2.0",
+                 params: %{
+                   changes: [
+                     %{
+                       type: GenLSP.Enumerations.FileChangeType.changed(),
+                       uri: unquote(uri)
+                     }
+                   ]
+                 }
+               })
+    end
+  end
+
   def apply_edit(code, edit) when is_binary(code), do: apply_edit(String.split(code, "\n"), edit)
 
   def apply_edit(lines, %TextEdit{} = edit) when is_list(lines) do