build elixir_sense metadata in parser

Author: lukaszsamson

apps/language_server/lib/language_server/parser.ex

@@ -8,16 +8,21 @@ defmodule ElixirLS.LanguageServer.Parser do
   alias ElixirLS.LanguageServer.Build
   alias ElixirLS.LanguageServer.Server
   alias ElixirLS.LanguageServer.SourceFile
+  alias ElixirSense.Core.MetadataBuilder
   require Logger
 
   @debounce_timeout 300
 
-  defstruct [
-    :source_file,
-    :path,
-    :ast,
-    :diagnostics
-  ]
+  defmodule Context do
+    defstruct [
+      :source_file,
+      :path,
+      :ast,
+      :diagnostics,
+      :metadata,
+      :parsed_version
+    ]
+  end
 
   def start_link(args) do
     GenServer.start_link(__MODULE__, args, name: __MODULE__)
@@ -31,6 +36,10 @@ defmodule ElixirLS.LanguageServer.Parser do
     GenServer.cast(__MODULE__, {:parse_with_debounce, uri, source_file})
   end
 
+  def parse_immediate(uri, source_file) do
+    GenServer.call(__MODULE__, {:parse_immediate, uri, source_file})
+  end
+
   @impl true
   def init(_args) do
     # TODO get source files on start?
@@ -58,33 +67,78 @@ defmodule ElixirLS.LanguageServer.Parser do
         Process.send_after(self(), {:parse_file, uri}, @debounce_timeout)
       end)
 
-      update_in(state.files[uri], fn _old_file ->
-        %__MODULE__{
-          source_file: source_file,
-          path: get_path(uri),
-          ast: nil,
-          diagnostics: []
-        }
+      update_in(state.files[uri], fn
+        nil ->
+          %Context{
+            source_file: source_file,
+            path: get_path(uri)
+          }
+        old_file ->
+          %Context{old_file |
+            source_file: source_file
+          }
       end)
     else
+      Logger.debug("Not parsing #{uri} with debounce")
       state
     end
 
     {:noreply, state}
   end
 
+  @impl true
+  def handle_call({:parse_immediate, uri, source_file}, _from, %{files: files, debounce_refs: debounce_refs} = state) do
+    {reply, state} = if String.ends_with?(uri, [".ex", ".exs", ".eex"]) do
+      {maybe_ref, updated_debounce_refs} = Map.pop(debounce_refs, uri)
+      if maybe_ref do
+        Process.cancel_timer(maybe_ref, info: false)
+      end
+
+      current_version = source_file.version
+
+      case files[uri] do
+        %Context{parsed_version: ^current_version} = file ->
+          Logger.debug("#{uri} already parsed")
+          # current version already parsed
+          {file, state}
+        _other ->
+          Logger.debug("Parsing #{uri} immediately")
+          # overwrite everything
+          file = %Context{
+            source_file: source_file,
+            path: get_path(uri)
+          }
+          |> do_parse()
+
+          updated_files = Map.put(files, uri, file)
+
+          notify_diagnostics_updated(updated_files)
+
+          state = %{state | files: updated_files, debounce_refs: updated_debounce_refs}
+          {file, state}
+      end
+    else
+      Logger.debug("Not parsing #{uri} immediately")
+      # not parsing - respond with empty struct
+      reply = %Context{
+        source_file: source_file,
+        path: get_path(uri)
+      }
+      {reply, state}
+    end
+
+    {:reply, reply, state}
+  end
+
   @impl GenServer
   def handle_info(
         {:parse_file, uri},
         %{files: files, debounce_refs: debounce_refs} = state
       ) do
-    Logger.debug("Parsing #{uri}")
-    %__MODULE__{source_file: source_file, path: path} = file = Map.fetch!(files, uri)
-    {ast, diagnostics} = parse_file(source_file.text, path)
-    updated_file = %__MODULE__{file |
-      ast: ast,
-      diagnostics: diagnostics
-    }
+    Logger.debug("Parsing #{uri} after debounce")
+
+    updated_file = Map.fetch!(files, uri)
+    |> do_parse()
 
     updated_files = Map.put(files, uri, updated_file)
 
@@ -95,10 +149,27 @@ defmodule ElixirLS.LanguageServer.Parser do
     {:noreply, state}
   end
 
+  defp do_parse(%Context{source_file: source_file, path: path} = file) do
+    {ast, diagnostics} = parse_file(source_file.text, path)
+
+    metadata = if ast do
+      acc = MetadataBuilder.build(ast)
+      ElixirSense.Core.Metadata.fill(source_file.text, acc)
+    end
+
+    %Context{file |
+      ast: ast,
+      diagnostics: diagnostics,
+      metadata: metadata,
+      parsed_version: source_file.version
+    }
+  end
+
   defp get_path(uri) do
     case uri do
       "file:" <> _ -> SourceFile.Path.from_uri(uri)
       _ ->
+        # TODO think if this is sane
         extension = uri
         |> String.split(".")
         |> List.last
@@ -108,7 +179,7 @@ defmodule ElixirLS.LanguageServer.Parser do
 
   defp notify_diagnostics_updated(updated_files) do
     updated_files
-    |> Enum.map(fn {_uri, %__MODULE__{diagnostics: diagnostics}} -> diagnostics end)
+    |> Enum.map(fn {_uri, %Context{diagnostics: diagnostics}} -> diagnostics end)
     |> List.flatten
     |> Server.parser_finished()
   end

apps/language_server/lib/language_server/providers/completion.ex

@@ -8,7 +8,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
   text before the cursor so we can filter out suggestions that are not relevant.
   """
   alias ElixirLS.LanguageServer.Protocol.TextEdit
-  alias ElixirLS.LanguageServer.SourceFile
+  alias ElixirLS.LanguageServer.{SourceFile, Parser}
   import ElixirLS.LanguageServer.Protocol, only: [range: 4]
   alias ElixirSense.Providers.Suggestion.Matcher
   alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
@@ -93,7 +93,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
     [".", "@", "&", "%", "^", ":", "!", "-", "~"]
   end
 
-  def completion(text, line, character, options) do
+  def completion(%Parser.Context{source_file: %SourceFile{text: text}, metadata: metadata}, line, character, options) do
     lines = SourceFile.lines(text)
     line_text = Enum.at(lines, line)
 
@@ -106,8 +106,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
 
     prefix = get_prefix(text_before_cursor)
 
-    # Can we use ElixirSense.Providers.Suggestion? ElixirSense.suggestions/3
-    metadata = ElixirSense.Core.Parser.parse_string(text, true, true, {line, character})
+    metadata = metadata || ElixirSense.Core.Parser.parse_string(text, true, true, {line, character})
 
     env = ElixirSense.Core.Metadata.get_env(metadata, {line, character})
 
@@ -173,8 +172,9 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
         SourceFile.elixir_position_to_lsp(text, position_to_insert_alias)
       )
 
-    items =
-      build_suggestions(text, line, character, options)
+    required_alias = Keyword.get(options, :auto_insert_required_alias, true)
+
+    items = ElixirSense.suggestions(text, line, character, required_alias: required_alias, metadata: metadata)
       |> maybe_reject_derived_functions(context, options)
       |> Enum.map(&from_completion_item(&1, context, options))
       |> maybe_add_do(context)
@@ -215,11 +215,6 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
     {:ok, %{"isIncomplete" => is_incomplete(items_json), "items" => items_json}}
   end
 
-  defp build_suggestions(text, line, character, options) do
-    required_alias = Keyword.get(options, :auto_insert_required_alias, true)
-    ElixirSense.suggestions(text, line, character, required_alias: required_alias)
-  end
-
   defp maybe_add_do(completion_items, context) do
     hint =
       case Regex.scan(~r/(?<=\s|^)[a-z]+$/u, context.text_before_cursor) do

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

@@ -1,20 +1,20 @@
 defmodule ElixirLS.LanguageServer.Providers.Definition do
   @moduledoc """
-  Go-to-definition provider utilizing Elixir Sense
+  textDocument/definition provider utilizing Elixir Sense
   """
 
-  alias ElixirLS.LanguageServer.{Protocol, SourceFile}
+  alias ElixirLS.LanguageServer.{Protocol, SourceFile, Parser}
 
-  def definition(uri, text, line, character, project_dir) do
-    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
+  def definition(uri, %Parser.Context{source_file: source_file, metadata: metadata}, line, character, project_dir) do
+    {line, character} = SourceFile.lsp_position_to_elixir(source_file.text, {line, character})
 
     result =
-      case ElixirSense.definition(text, line, character) do
+      case ElixirSense.definition(source_file.text, line, character, if(metadata, do: [metadata: metadata], else: [])) do
         nil ->
           nil
 
         %ElixirSense.Location{} = location ->
-          Protocol.Location.new(location, uri, text, project_dir)
+          Protocol.Location.new(location, uri, source_file.text, project_dir)
       end
 
     {:ok, result}

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

@@ -1,22 +1,22 @@
 defmodule ElixirLS.LanguageServer.Providers.Hover do
-  alias ElixirLS.LanguageServer.{SourceFile, DocLinks}
+  alias ElixirLS.LanguageServer.{SourceFile, DocLinks, Parser}
   import ElixirLS.LanguageServer.Protocol
   alias ElixirLS.LanguageServer.MarkdownUtils
 
   @moduledoc """
-  Hover provider utilizing Elixir Sense
+  textDocument/hover provider utilizing Elixir Sense
   """
 
-  def hover(text, line, character, _project_dir) do
-    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
+  def hover(%Parser.Context{source_file: source_file, metadata: metadata}, line, character) do
+    {line, character} = SourceFile.lsp_position_to_elixir(source_file.text, {line, character})
 
     response =
-      case ElixirSense.docs(text, line, character) do
+      case ElixirSense.docs(source_file.text, line, character, if(metadata, do: [metadata: metadata], else: [])) do
         nil ->
           nil
 
         %{docs: docs, range: es_range} ->
-          lines = SourceFile.lines(text)
+          lines = SourceFile.lines(source_file.text)
 
           try do
             %{

apps/language_server/lib/language_server/providers/implementation.ex

@@ -1,16 +1,16 @@
 defmodule ElixirLS.LanguageServer.Providers.Implementation do
   @moduledoc """
-  Go-to-implementation provider utilizing Elixir Sense
+  textDocument/implementation provider utilizing Elixir Sense
   """
 
-  alias ElixirLS.LanguageServer.{Protocol, SourceFile}
+  alias ElixirLS.LanguageServer.{Protocol, SourceFile, Parser}
 
-  def implementation(uri, text, line, character, project_dir) do
-    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
-    locations = ElixirSense.implementations(text, line, character)
+  def implementation(uri, %Parser.Context{source_file: source_file, metadata: metadata}, line, character, project_dir) do
+    {line, character} = SourceFile.lsp_position_to_elixir(source_file.text, {line, character})
+    locations = ElixirSense.implementations(source_file.text, line, character, if(metadata, do: [metadata: metadata], else: []))
 
     results =
-      for location <- locations, do: Protocol.Location.new(location, uri, text, project_dir)
+      for location <- locations, do: Protocol.Location.new(location, uri, source_file.text, project_dir)
 
     {:ok, results}
   end

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

@@ -1,6 +1,6 @@
 defmodule ElixirLS.LanguageServer.Providers.References do
   @moduledoc """
-  This module provides References support by using `ElixirSense.references/3` to
+  This module provides textDocument/references support by using `ElixirSense.references/3` to
   find all references to any function or module identified at the provided
   location.
 
@@ -10,20 +10,20 @@ defmodule ElixirLS.LanguageServer.Providers.References do
   https://microsoft.github.io//language-server-protocol/specifications/specification-3-14/#textDocument_references
   """
 
-  alias ElixirLS.LanguageServer.{SourceFile, Build}
+  alias ElixirLS.LanguageServer.{SourceFile, Build, Parser}
   import ElixirLS.LanguageServer.Protocol
   require Logger
 
-  def references(text, uri, line, character, _include_declaration, project_dir) do
-    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
+  def references(%Parser.Context{source_file: source_file, metadata: metadata}, uri, line, character, _include_declaration, project_dir) do
+    {line, character} = SourceFile.lsp_position_to_elixir(source_file.text, {line, character})
 
     Build.with_build_lock(fn ->
       trace = ElixirLS.LanguageServer.Tracer.get_trace()
 
-      ElixirSense.references(text, line, character, trace)
+      ElixirSense.references(source_file.text, line, character, trace, if(metadata, do: [metadata: metadata], else: []))
       |> Enum.map(fn elixir_sense_reference ->
         elixir_sense_reference
-        |> build_reference(uri, text, project_dir)
+        |> build_reference(uri, source_file.text, project_dir)
       end)
       |> Enum.filter(&(not is_nil(&1)))
       # ElixirSense returns references from both compile tracer and current buffer

apps/language_server/lib/language_server/providers/signature_help.ex

@@ -1,13 +1,16 @@
 defmodule ElixirLS.LanguageServer.Providers.SignatureHelp do
-  alias ElixirLS.LanguageServer.SourceFile
+  @moduledoc """
+  Provider handling textDocument/signatureHelp
+  """
+  alias ElixirLS.LanguageServer.{SourceFile, Parser}
 
   def trigger_characters(), do: ["(", ","]
 
-  def signature(%SourceFile{} = source_file, line, character) do
+  def signature(%Parser.Context{source_file: %SourceFile{} = source_file, metadata: metadata}, line, character) do
     {line, character} = SourceFile.lsp_position_to_elixir(source_file.text, {line, character})
 
     response =
-      case ElixirSense.signature(source_file.text, line, character) do
+      case ElixirSense.signature(source_file.text, line, character, if(metadata, do: [metadata: metadata], else: [])) do
         %{active_param: active_param, signatures: signatures} ->
           %{
             "activeSignature" => 0,