Merge pull request #1266 from elixir-lsp/inlay-hints

Inlay hints: variable types + parameter names (TypeHints facade)

Author: lukaszsamson

.dialyzer_ignore.exs

@@ -6,6 +6,10 @@
   {"lib/language_server/providers/execute_command/restart.ex", :no_return},
   # @erlang_ex_doc? is true on OTP >= 27. Else branches needed for OTP 26 but appear dead when compiled on OTP 27+.
   {"lib/language_server/markdown_utils.ex", :pattern_match},
+  # :elixir_tokenizer.tokenize returns a 6-tuple on 1.17+ but a 5-tuple on 1.16
+  # (and older forms a 4-tuple); the extra clauses are needed at runtime on old
+  # Elixirs but appear dead when analyzed against the 1.20 PLT.
+  {"lib/language_server/providers/inlay_hints.ex", :pattern_match},
   # Conditional Code.ensure_loaded?/Version.match? branches that dialyzer evaluates statically based on the build environment.
   {"lib/launch.ex", :pattern_match},
   # Code.Fragment.cursor_context/1 spec in Elixir 1.20 omits :capture_arg, but runtime may still emit it.

.github/workflows/ci.yml

@@ -9,6 +9,18 @@ on:
       - master
 
 jobs:
+  # Release gate: absolute local path dependencies must never ship. The
+  # elixir_sense dependency is a git pin (dep_versions.exs), so this job
+  # hard-fails on any reintroduction of a local path dep.
+  release-gate:
+    name: Reject absolute path deps (release gate)
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check for absolute local path dependencies
+        run: |
+          ! grep -rn 'path: "/' --include=mix.exs --include=mix.lock .
+
   # Smoke test on the highest supported OTP for each Elixir version
   smoke_test_language_server:
     name: Smoke test language server (Elixir ${{matrix.elixir}} | OTP ${{matrix.otp}})

apps/elixir_ls_utils/lib/completion_engine.ex

@@ -71,6 +71,7 @@ defmodule ElixirLS.Utils.CompletionEngine do
   alias ElixirSense.Core.State.StructInfo
   alias ElixirSense.Core.Struct
   alias ElixirSense.Core.TypeInfo
+  alias ElixirSense.Core.TypePresentation
 
   alias ElixirLS.Utils.Matcher
 
@@ -2021,7 +2022,10 @@ defmodule ElixirLS.Utils.CompletionEngine do
         value_is_map: value_is_map,
         origin: if(subtype == :struct_field and origin != nil, do: inspect(origin)),
         call?: true,
-        type_spec: map_field_spec(key, types, origin),
+        # Prefer the declared typespec; fall back to the inferred field type
+        # rendered from the resolved receiver shape (plain maps, or struct
+        # fields without a @type).
+        type_spec: map_field_spec(key, types, origin) || rendered_field_type(value),
         summary: doc,
         metadata: meta
       }
@@ -2072,6 +2076,17 @@ defmodule ElixirLS.Utils.CompletionEngine do
     end
   end
 
+  # Fallback when a field has no declared typespec: render the inferred field
+  # type (from the resolved receiver shape) to text. elixir-ls `type_spec` is a
+  # string, so render directly (no AST round-trip). Bare `term()`/`none()` carry
+  # no information, so they are dropped (a nested `%{a: term()}` is still kept).
+  defp rendered_field_type(value) do
+    case TypePresentation.render(value) do
+      {:ok, text} when text not in ["term()", "none()"] -> text
+      _ -> nil
+    end
+  end
+
   ## Ad-hoc conversions
   @spec to_entries(map) :: t()
 

apps/elixir_ls_utils/test/complete_test.exs

@@ -917,7 +917,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                  type: :field,
                  origin: nil,
                  call?: true,
-                 type_spec: nil,
+                 type_spec: "String",
                  value_is_map: false,
                  summary: "",
                  metadata: %{}
@@ -945,7 +945,8 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                  type: :field,
                  origin: nil,
                  call?: true,
-                 type_spec: nil,
+                 type_spec:
+                   "%{deeply: %{foo: term(), bar_1: term(), bar_2: term(), mod: String, num: term()}}",
                  value_is_map: true,
                  summary: "",
                  metadata: %{}
@@ -960,7 +961,8 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                  type: :field,
                  origin: nil,
                  call?: true,
-                 type_spec: nil,
+                 type_spec:
+                   "%{foo: term(), bar_1: term(), bar_2: term(), mod: String, num: term()}",
                  value_is_map: true,
                  summary: "",
                  metadata: %{}
@@ -1881,7 +1883,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                  type: :field,
                  origin: "ElixirLS.Utils.CompletionEngineTest.MyStruct",
                  call?: true,
-                 type_spec: nil,
+                 type_spec: "%{asdf: term()}",
                  value_is_map: true,
                  summary: "",
                  metadata: %{}
@@ -1981,7 +1983,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                  type: :field,
                  origin: "ElixirLS.Utils.CompletionEngineTest.MyStruct",
                  call?: true,
-                 type_spec: nil,
+                 type_spec: "%ElixirLS.Utils.CompletionEngineTest.MyStruct{}",
                  value_is_map: true,
                  summary: "",
                  metadata: %{}
@@ -2016,19 +2018,19 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
   end
 
   test "completion for bitstring modifiers" do
-    assert entries = expand('<<foo::') |> Enum.filter(&(&1[:type] == :bitstring_option))
+    assert entries = expand(~c"<<foo::") |> Enum.filter(&(&1[:type] == :bitstring_option))
     assert Enum.any?(entries, &(&1.name == "integer"))
     assert Enum.any?(entries, &(&1.name == "size" and &1.arity == 1))
 
-    assert [%{name: "integer", type: :bitstring_option}] = expand('<<foo::int')
+    assert [%{name: "integer", type: :bitstring_option}] = expand(~c"<<foo::int")
 
-    assert entries = expand('<<foo::integer-') |> Enum.filter(&(&1[:type] == :bitstring_option))
+    assert entries = expand(~c"<<foo::integer-") |> Enum.filter(&(&1[:type] == :bitstring_option))
     refute Enum.any?(entries, &(&1.name == "integer"))
     assert Enum.any?(entries, &(&1.name == "little"))
     assert Enum.any?(entries, &(&1.name == "size" and &1.arity == 1))
 
     assert entries =
-             expand('<<foo::integer-little-') |> Enum.filter(&(&1[:type] == :bitstring_option))
+             expand(~c"<<foo::integer-little-") |> Enum.filter(&(&1[:type] == :bitstring_option))
 
     refute Enum.any?(entries, &(&1.name == "integer"))
     refute Enum.any?(entries, &(&1.name == "little"))
@@ -2602,7 +2604,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
     # In module context, we should only module functions
     entries =
       expand(
-        '@module_attr.',
+        ~c"@module_attr.",
         module_env,
         metadata
       )
@@ -2613,7 +2615,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
     # In def context, we should get both module and function
     entries =
       expand(
-        '@module_attr.',
+        ~c"@module_attr.",
         module_env |> Map.put(:function, {:bar, 0}),
         metadata
       )

apps/language_server/lib/language_server.ex

@@ -25,6 +25,16 @@ defmodule ElixirLS.LanguageServer do
     Launch.start_mix()
 
     Application.put_env(:elixir_sense, :logging_enabled, Mix.env() != :prod)
+
+    # Apply ELIXIR_LS_TYPE_INFERENCE env var at runtime. This must happen here
+    # because config.exs is evaluated at build time and has no effect in releases.
+    use_elixir_types =
+      System.get_env("ELIXIR_LS_TYPE_INFERENCE", "true")
+      |> String.downcase()
+      |> then(&(&1 not in ["false", "0"]))
+
+    Application.put_env(:elixir_sense, :use_elixir_types, use_elixir_types)
+
     Build.set_compiler_options()
 
     start_language_server()

apps/language_server/lib/language_server/markdown_utils.ex

@@ -428,7 +428,16 @@ defmodule ElixirLS.LanguageServer.MarkdownUtils do
   @kernel_special_forms_exports Kernel.SpecialForms.__info__(:macros)
   @kernel_exports Kernel.__info__(:macros) ++ Kernel.__info__(:functions)
 
-  defp get_module_fun_arity("..///3"), do: {Kernel, :..//, 3}
+  # NOTE: `String.to_atom("..//")` rather than the literal `:..//` atom because
+  # the two supported formatters disagree on how to render that atom — Elixir
+  # 1.20 emits it unquoted (`:..//`) while 1.16 quotes it (`:"..//"`), so no
+  # single literal form is `mix format --check-formatted`-clean on both. The
+  # string form is left untouched by every formatter and yields the same atom.
+  # Computed once at compile time (module attribute) to keep the dynamic-atom
+  # call out of the per-invocation path.
+  @stepped_range_atom String.to_atom("..//")
+
+  defp get_module_fun_arity("..///3"), do: {Kernel, @stepped_range_atom, 3}
   defp get_module_fun_arity("../2"), do: {Kernel, :.., 2}
   defp get_module_fun_arity("../0"), do: {Kernel, :.., 0}
   defp get_module_fun_arity("./2"), do: {Kernel.SpecialForms, :., 2}

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

@@ -228,12 +228,29 @@ defmodule ElixirLS.LanguageServer.Providers.Hover do
   end
 
   defp format_doc(info = %{kind: :variable}) do
+    type_section =
+      case Map.get(info, :type) do
+        type when is_binary(type) and type != "" ->
+          """
+
+          ### Type
+
+          ```elixir
+          #{type}
+          ```
+          """
+
+        _ ->
+          ""
+      end
+
     """
     ```elixir
     #{info.name}
     ```
 
     *variable*
+    #{type_section}
     """
   end
 

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

@@ -18,6 +18,7 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
   alias ElixirSense.Core.SurroundContext
   alias ElixirSense.Core.State.{ModFunInfo, SpecInfo}
   alias ElixirSense.Core.TypeInfo
+  alias ElixirSense.Core.TypePresentation
   alias ElixirSense.Core.Parser
   alias ElixirSense.Core.Source
 
@@ -49,7 +50,8 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
 
   @type variable_doc :: %{
           name: atom(),
-          kind: :variable
+          kind: :variable,
+          type: String.t() | nil
         }
 
   @type attribute_doc :: %{
@@ -137,9 +139,16 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
         var_info = Metadata.find_var(metadata, variable, version, context.begin)
 
         if var_info != nil do
+          type =
+            case TypePresentation.render_hint(binding_env, var_info) do
+              {:ok, text} -> text
+              :skip -> nil
+            end
+
           %{
             name: Atom.to_string(variable),
-            kind: :variable
+            kind: :variable,
+            type: type
           }
         else
           mod_fun_docs(