suggest record fields from compiled records on 1.18+

Author: lukaszsamson

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

@@ -7,6 +7,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Record do
   alias ElixirSense.Core.State
   alias ElixirSense.Core.State.{RecordInfo, TypeInfo}
   alias ElixirLS.Utils.Matcher
+  alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
 
   @type field :: %{
           type: :field,
@@ -95,8 +96,8 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Record do
              cursor_position,
              not elixir_prefix
            ),
-         %RecordInfo{} = info <- records[{mod, fun}] do
-      fields = get_fields(hint, mod, fun, info.fields, options_so_far, metadata_types)
+         fields_info when is_list(fields_info) <- get_record_info(mod, fun, records) do
+      fields = get_fields(hint, mod, fun, fields_info, options_so_far, metadata_types)
 
       {fields, if(npar == 0 and cursor_at_option in [false, :maybe], do: :maybe_record_update)}
     else
@@ -105,6 +106,27 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Record do
     end
   end
 
+  defp get_record_info(mod, fun, records) do
+    case records[{mod, fun}] do
+      %RecordInfo{} = info ->
+        info.fields
+
+      nil ->
+        if Version.match?(System.version(), ">= 1.18.0-dev") do
+          case NormalizedCode.get_docs(mod, :docs) do
+            nil ->
+              nil
+
+            docs ->
+              Enum.find_value(docs, fn
+                {{^fun, 1}, _, :macro, _, _, %{record: {_tag, fields}}} -> fields
+                _ -> nil
+              end)
+          end
+        end
+    end
+  end
+
   defp get_fields(hint, module, record_name, fields, fields_so_far, types) do
     field_types = get_field_types(types, module, record_name)
 
@@ -154,7 +176,47 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Record do
          when kind in [:type, :typep, :opaque] <- ast do
       field_types
     else
-      _ -> []
+      _ ->
+        candidates =
+          if Version.match?(System.version(), ">= 1.18.0-dev") do
+            ElixirSense.Core.TypeInfo.find_all(module, fn info ->
+              info.name in [record, :"#{record}_t", :t] and info.arity == 0
+            end)
+          else
+            []
+          end
+
+        with [info | _] <- candidates,
+             {:ok, ast} <- Code.string_to_quoted(info.spec),
+             {:@, _,
+              [
+                {kind, _,
+                 [
+                   {:"::", _,
+                    [
+                      {_name, _, []},
+                      {:{}, _,
+                       [
+                         _tag
+                         | field_types
+                       ]}
+                    ]}
+                 ]}
+              ]}
+             when kind in [:type, :typep, :opaque] <- ast do
+          field_types
+          |> Enum.map(fn
+            {:"::", _, [{name, _, context}, type]} when is_atom(name) and is_atom(context) ->
+              {name, type}
+
+            _ ->
+              nil
+          end)
+          |> Enum.reject(&is_nil/1)
+        else
+          _ ->
+            []
+        end
     end
   end
 end

apps/language_server/test/providers/completion/suggestions_test.exs

@@ -4972,6 +4972,81 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
            ] = suggestions |> Enum.filter(&(&1.name == "user"))
   end
 
+  test "records fields" do
+    buffer = """
+    defmodule SomeSchema do
+      require ElixirSenseExample.ModuleWithRecord, as: R
+
+      def d() do
+        w = R.user()
+        w = R.user(n)
+        R.user(w, n)
+        R.user(w, name: "1", a)
+      end
+    end
+    """
+
+    suggestions = Suggestion.suggestions(buffer, 5, 16)
+
+    assert [
+             %{
+               name: "age",
+               origin: "ElixirSenseExample.ModuleWithRecord.user",
+               type: :field,
+               call?: false,
+               subtype: :record_field,
+               type_spec: "integer()"
+             },
+             %{
+               name: "name",
+               origin: "ElixirSenseExample.ModuleWithRecord.user",
+               type: :field,
+               call?: false,
+               subtype: :record_field,
+               type_spec: "String.t()"
+             }
+           ] = suggestions |> Enum.filter(&(&1.type == :field))
+
+    suggestions = Suggestion.suggestions(buffer, 6, 17)
+
+    assert [
+             %{
+               name: "name",
+               origin: "ElixirSenseExample.ModuleWithRecord.user",
+               type: :field,
+               call?: false,
+               subtype: :record_field,
+               type_spec: "String.t()"
+             }
+           ] = suggestions |> Enum.filter(&(&1.type == :field))
+
+    suggestions = Suggestion.suggestions(buffer, 7, 16)
+
+    assert [
+             %{
+               name: "name",
+               origin: "ElixirSenseExample.ModuleWithRecord.user",
+               type: :field,
+               call?: false,
+               subtype: :record_field,
+               type_spec: "String.t()"
+             }
+           ] = suggestions |> Enum.filter(&(&1.type == :field))
+
+    suggestions = Suggestion.suggestions(buffer, 8, 27)
+
+    assert [
+             %{
+               name: "age",
+               origin: "ElixirSenseExample.ModuleWithRecord.user",
+               type: :field,
+               call?: false,
+               subtype: :record_field,
+               type_spec: "integer()"
+             }
+           ] = suggestions |> Enum.filter(&(&1.type == :field))
+  end
+
   test "records from metadata fields" do
     buffer = """
     defmodule SomeSchema do