rename struct fields

Author: lukaszsamson

lib/elixir_sense/core/binding.ex

@@ -10,28 +10,28 @@ defmodule ElixirSense.Core.Binding do
 
   # TODO refactor to use env
   defstruct structs: %{},
-            variables: [],
+            vars: [],
             attributes: [],
-            current_module: nil,
+            module: nil,
             function: nil,
             functions: [],
             macros: [],
             specs: %{},
             types: %{},
-            mods_funs: %{}
+            mods_funs_to_positions: %{}
 
   def from_env(%State.Env{} = env, %ElixirSense.Core.Metadata{} = metadata) do
     %Binding{
-      variables: env.vars,
+      vars: env.vars,
       attributes: env.attributes,
       structs: metadata.structs,
       functions: env.functions,
       macros: env.macros,
       specs: metadata.specs,
-      current_module: env.module,
+      module: env.module,
       function: env.function,
       types: metadata.types,
-      mods_funs: metadata.mods_funs_to_positions
+      mods_funs_to_positions: metadata.mods_funs_to_positions
     }
   end
 
@@ -86,7 +86,7 @@ defmodule ElixirSense.Core.Binding do
     expand(env, combined, stack)
   end
 
-  def do_expand(%Binding{variables: variables} = env, {:variable, variable, version}, stack) do
+  def do_expand(%Binding{vars: variables} = env, {:variable, variable, version}, stack) do
     sorted_variables = Enum.sort_by(variables, &{&1.name, -&1.version})
 
     type =
@@ -299,7 +299,7 @@ defmodule ElixirSense.Core.Binding do
 
   # local call
   def do_expand(
-        %Binding{functions: functions, macros: macros, current_module: current_module} = env,
+        %Binding{functions: functions, macros: macros} = env,
         {:local_call, function, arguments},
         stack
       ) do
@@ -311,9 +311,9 @@ defmodule ElixirSense.Core.Binding do
         |> Introspection.combine_imports()
 
       candidate_targets =
-        if current_module && env.function do
+        if env.module && env.function do
           # locals are available only in defs
-          [current_module]
+          [env.module]
         else
           []
         end ++ combined_imports ++ [Kernel.SpecialForms]
@@ -329,7 +329,7 @@ defmodule ElixirSense.Core.Binding do
 
         candidate ->
           # include private from current module
-          include_private = candidate == current_module
+          include_private = candidate == env.module
           expand_call(env, {:atom, candidate}, function, arguments, include_private, stack)
       end)
       |> drop_no_spec
@@ -1324,15 +1324,15 @@ defmodule ElixirSense.Core.Binding do
   end
 
   defp expand_call_from_metadata(
-         %Binding{specs: specs, mods_funs: mods_funs} = env,
+         %Binding{specs: specs, mods_funs_to_positions: mods_funs_to_positions} = env,
          mod,
          fun,
          arity,
          include_private,
          stack
        ) do
     arity =
-      Enum.find_value(mods_funs, nil, fn
+      Enum.find_value(mods_funs_to_positions, nil, fn
         {{^mod, ^fun, _}, %State.ModFunInfo{type: fun_type} = info}
         when (include_private and fun_type != :def) or
                fun_type in [:def, :defmacro, :defguard, :defdelegate] ->

lib/elixir_sense/core/source.ex

@@ -572,8 +572,8 @@ defmodule ElixirSense.Core.Source do
   end
 
   def get_mod_fun([{:__MODULE__, _, nil}, fun], binding_env) do
-    if binding_env.current_module != nil do
-      {{binding_env.current_module, false}, fun}
+    if binding_env.module != nil do
+      {{binding_env.module, false}, fun}
     end
   end
 
@@ -607,9 +607,9 @@ defmodule ElixirSense.Core.Source do
   end
 
   def get_mod([{:__MODULE__, _, nil} | rest], binding_env) do
-    if binding_env.current_module != nil do
+    if binding_env.module != nil do
       mod =
-        binding_env.current_module
+        binding_env.module
         |> Module.split()
         |> Kernel.++(rest)
         |> Module.concat()

lib/elixir_sense/providers/completion/reducers/record.ex

@@ -45,32 +45,17 @@ defmodule ElixirSense.Providers.Completion.Reducers.Record do
     end
   end
 
-  defp find_record_fields(hint, text_before, env, metadata, cursor_position) do
-    %State.Env{
-      module: module,
-      vars: vars,
-      attributes: attributes
-    } = env
-
-    %Metadata{
-      structs: structs,
-      records: records,
-      mods_funs_to_positions: mods_funs,
-      types: metadata_types,
-      specs: specs
-    } = metadata
-
-    binding_env = %ElixirSense.Core.Binding{
-      attributes: attributes,
-      variables: vars,
-      structs: structs,
-      functions: env.functions,
-      macros: env.macros,
-      current_module: module,
-      specs: specs,
-      types: metadata_types,
-      mods_funs: mods_funs
-    }
+  defp find_record_fields(
+         hint,
+         text_before,
+         %State.Env{} = env,
+         %Metadata{
+           records: records,
+           types: metadata_types
+         } = metadata,
+         cursor_position
+       ) do
+    binding_env = ElixirSense.Core.Binding.from_env(env, metadata)
 
     # check if we are inside local or remote call arguments and parameter is 0, 1 or 2
     # record fields can specified on 0, 1 and 2 position in the argument list

lib/elixir_sense/providers/completion/reducers/struct.ex

@@ -44,32 +44,16 @@ defmodule ElixirSense.Providers.Completion.Reducers.Struct do
     end
   end
 
-  defp find_struct_fields(hint, text_before, env, buffer_metadata) do
-    %State.Env{
-      module: module,
-      vars: vars,
-      attributes: attributes,
-      aliases: aliases
-    } = env
-
-    %Metadata{
-      structs: structs,
-      mods_funs_to_positions: mods_funs,
-      types: metadata_types,
-      specs: specs
-    } = buffer_metadata
-
-    env = %ElixirSense.Core.Binding{
-      attributes: attributes,
-      variables: vars,
-      structs: structs,
-      functions: env.functions,
-      macros: env.macros,
-      current_module: module,
-      specs: specs,
-      types: metadata_types,
-      mods_funs: mods_funs
-    }
+  defp find_struct_fields(
+         hint,
+         text_before,
+         %State.Env{
+           module: module,
+           aliases: aliases
+         } = env,
+         %Metadata{} = buffer_metadata
+       ) do
+    binding_env = ElixirSense.Core.Binding.from_env(env, buffer_metadata)
 
     case Source.which_struct(text_before, module) do
       {type, fields_so_far, elixir_prefix, var} ->
@@ -84,13 +68,13 @@ defmodule ElixirSense.Providers.Completion.Reducers.Struct do
               type
           end
 
-        type = Binding.expand(env, {:struct, [], type, var})
+        type = Binding.expand(binding_env, {:struct, [], type, var})
 
         result = get_fields(buffer_metadata, type, hint, fields_so_far)
         {result, if(fields_so_far == [], do: :maybe_struct_update)}
 
       {:map, fields_so_far, var} ->
-        var = Binding.expand(env, var)
+        var = Binding.expand(binding_env, var)
 
         result = get_fields(buffer_metadata, var, hint, fields_so_far)
         {result, if(fields_so_far == [], do: :maybe_struct_update)}