register struct expansion

Author: lukaszsamson

lib/elixir_sense/core/compiler.ex

@@ -9,11 +9,24 @@ defmodule ElixirSense.Core.Compiler do
   alias ElixirSense.Core.State.ModFunInfo
 
   @trace_key :elixir_sense_trace
+  @trace_paused_key :elixir_sense_trace_paused
+
+  def pause_trace do
+    Process.put(@trace_paused_key, true)
+  end
+
+  def resume_trace do
+    Process.delete(@trace_paused_key)
+  end
 
   def trace(event, env) do
-    trace = get_trace()
-    Process.put(@trace_key, [{event, env} | trace])
-    :ok
+    if Process.get(@trace_paused_key) do
+      :ok
+    else
+      trace = get_trace()
+      Process.put(@trace_key, [{event, env} | trace])
+      :ok
+    end
   end
 
   defp get_trace do
@@ -63,6 +76,12 @@ defmodule ElixirSense.Core.Compiler do
             acc
             |> State.add_call_to_line({env.module, name, arity}, meta, kind)
 
+          {:struct_expansion, meta, name, _assocs} ->
+            acc
+            |> State.add_call_to_line({name, nil, nil}, meta, :struct_expansion)
+
+          # TODO: handle :alias_expansion
+
           _ ->
             Logger.warning("Unhandled trace event: #{inspect(event)}")
             acc
@@ -1728,40 +1747,42 @@ defmodule ElixirSense.Core.Compiler do
     # here we handle module callbacks. Only before_compile macro callbacks are expanded as they
     # affect module body. Func before_compile callbacks are not executed. after_compile and after_verify
     # are not executed as we do not preform a real compilation
-    {state, _e_env} = ~w(before_compile after_compile after_verify)a
-    |> Enum.reduce({state, e_env}, fn attribute, {state, env} ->
-      for args <- Map.get(state.attribute_store, {full, attribute}, []) do
-        case args do
-          {module, fun} -> [module, fun]
-          module -> [module, :"__#{attribute}__"]
-        end
-      end
-      |> Enum.reduce({state, e_env}, fn target, {state, env} ->
-        # module vars are not accessible in module callbacks
-        env = %{env | versioned_vars: %{}, line: meta[:line]}
-        state_orig = state
-        state = State.new_func_vars_scope(state)
-
-        # elixir dispatches callbacks by raw dispatch and eval_forms
-        # instead we expand a bock with require and possibly expand macros
-        # we do not attempt to exec function callbacks
-        args = case attribute do
-          :before_compile -> [env]
-          :after_compile -> [env, <<>>]
-          :after_verify -> [full]
+    {state, _e_env} =
+      ~w(before_compile after_compile after_verify)a
+      |> Enum.reduce({state, e_env}, fn attribute, {state, env} ->
+        for args <- Map.get(state.attribute_store, {full, attribute}, []) do
+          case args do
+            {module, fun} -> [module, fun]
+            module -> [module, :"__#{attribute}__"]
+          end
         end
+        |> Enum.reduce({state, e_env}, fn target, {state, env} ->
+          # module vars are not accessible in module callbacks
+          env = %{env | versioned_vars: %{}, line: meta[:line]}
+          state_orig = state
+          state = State.new_func_vars_scope(state)
+
+          # elixir dispatches callbacks by raw dispatch and eval_forms
+          # instead we expand a bock with require and possibly expand macros
+          # we do not attempt to exec function callbacks
+          args =
+            case attribute do
+              :before_compile -> [env]
+              :after_compile -> [env, <<>>]
+              :after_verify -> [full]
+            end
 
-        ast =
-          {:__block__, [],
-           [
-             {:require, [], [hd(target)]},
-             {{:., [line: meta[:line]], target}, [line: meta[:line]], args}
-           ]}
+          ast =
+            {:__block__, [],
+             [
+               {:require, [], [hd(target)]},
+               {{:., [line: meta[:line]], target}, [line: meta[:line]], args}
+             ]}
 
-        {_result, state, env} = expand(ast, state, env)
-        {State.remove_func_vars_scope(state, state_orig), env}
+          {_result, state, env} = expand(ast, state, env)
+          {State.remove_func_vars_scope(state, state_orig), env}
+        end)
       end)
-    end)
 
     # restore vars from outer scope
     # restore version counter

lib/elixir_sense/core/compiler/map.ex

@@ -9,11 +9,10 @@ defmodule ElixirSense.Core.Compiler.Map do
 
     case validate_struct(e_left, context) do
       true when is_atom(e_left) ->
-        # TODO register alias/struct
         case extract_struct_assocs(e_right) do
           {:expand, map_meta, assocs} when context != :match ->
             assoc_keys = Enum.map(assocs, fn {k, _} -> k end)
-            struct = load_struct(e_left, [assocs], se, ee)
+            struct = load_struct(meta, e_left, [assocs], se, ee)
             keys = [:__struct__ | assoc_keys]
             without_keys = Elixir.Map.drop(struct, keys)
 
@@ -22,7 +21,8 @@ defmodule ElixirSense.Core.Compiler.Map do
 
             {{:%, meta, [e_left, {:%{}, map_meta, struct_assocs ++ assocs}]}, se, ee}
 
-          {_, _, _assocs} ->
+          {_, _, assocs} ->
+            :elixir_env.trace({:struct_expansion, meta, e_left, assocs}, e)
             # elixir validates assocs against struct keys
             # we don't need to validate keys
             {{:%, meta, [e_left, e_right]}, se, ee}
@@ -151,25 +151,29 @@ defmodule ElixirSense.Core.Compiler.Map do
     Keyword.delete(assocs, :__struct__)
   end
 
-  def load_struct(name, assocs, s, _e) do
+  def load_struct(meta, name, assocs, s, e) do
     case s.structs[name] do
       nil ->
         try do
           apply(name, :__struct__, assocs)
         else
           %{:__struct__ => ^name} = struct ->
+            :elixir_env.trace({:struct_expansion, meta, name, assocs}, e)
             struct
 
           _ ->
+            :elixir_env.trace({:struct_expansion, meta, name, assocs}, e)
             # recover from invalid return value
             [__struct__: name] |> merge_assocs(assocs)
         rescue
           _ ->
+            :elixir_env.trace({:struct_expansion, meta, name, assocs}, e)
             # recover from error by building the fake struct
             [__struct__: name] |> merge_assocs(assocs)
         end
 
       info ->
+        :elixir_env.trace({:struct_expansion, meta, name, assocs}, e)
         info.fields |> merge_assocs(assocs)
     end
   end

lib/elixir_sense/core/compiler/typespec.ex

@@ -98,7 +98,15 @@ defmodule ElixirSense.Core.Compiler.Typespec do
       end
       |> sanitize_args()
 
-    {_, state} = expand_typespec({name, name_meta, args}, :disabled, state, env)
+    Compiler.pause_trace()
+
+    state =
+      try do
+        {_, state} = expand_typespec({name, name_meta, args}, :disabled, state, env)
+        state
+      after
+        Compiler.resume_trace()
+      end
 
     {guard, state, env} =
       if is_list(guard) do
@@ -216,7 +224,15 @@ defmodule ElixirSense.Core.Compiler.Typespec do
         args
       end
 
-    {_, state} = expand_typespec({name, name_meta, args}, :disabled, state, env)
+    Compiler.pause_trace()
+
+    state =
+      try do
+        {_, state} = expand_typespec({name, name_meta, args}, :disabled, state, env)
+        state
+      after
+        Compiler.resume_trace()
+      end
 
     {state, var_names} =
       Enum.reduce(args, {state, []}, fn
@@ -333,9 +349,8 @@ defmodule ElixirSense.Core.Compiler.Typespec do
 
     case expanded do
       module when is_atom(module) ->
-        # TODO register alias/struct
         struct =
-          Compiler.Map.load_struct(module, [], state, caller)
+          Compiler.Map.load_struct(struct_meta, module, [], state, caller)
           |> Map.delete(:__struct__)
           |> Map.to_list()
 

lib/elixir_sense/core/state/call_info.ex

@@ -3,7 +3,7 @@ defmodule ElixirSense.Core.State.CallInfo do
   Reference info
   """
   @type t :: %ElixirSense.Core.State.CallInfo{
-          arity: non_neg_integer,
+          arity: non_neg_integer | nil,
           position: {non_neg_integer, pos_integer | nil},
           func: atom,
           mod: module | {:attribute, atom},