fix a couple of dialyzer errors

Author: lukaszsamson

lib/elixir_sense.ex

@@ -57,7 +57,7 @@ defmodule ElixirSense do
           boolean,
           keyword
         ) ::
-          {:ok, Macro.t()} | {:error, :parse_error}
+          {:ok, Macro.t()} | {:error, any()}
   def string_to_quoted(
         source,
         cursor_position \\ nil,
@@ -74,7 +74,7 @@ defmodule ElixirSense do
 
     case Parser.string_to_ast(source, string_to_ast_options) do
       {:ok, ast, _source, _error} -> {:ok, ast}
-      other -> other
+      other = {:error, _} -> other
     end
   end
 

lib/elixir_sense/core/introspection.ex

@@ -802,7 +802,7 @@ defmodule ElixirSense.Core.Introspection do
   @spec actual_module(
           nil | module,
           ElixirSense.Core.State.Env.t(),
-          ElixirSense.Core.State.mods_funs_to_positions_t(),
+          ElixirSense.Core.Compiler.State.mods_funs_to_positions_t(),
           boolean
         ) :: {nil | module, boolean}
   def actual_module(module, env, mods_funs, expand_aliases?) do
@@ -891,8 +891,8 @@ defmodule ElixirSense.Core.Introspection do
   @spec actual_mod_fun(
           {nil | module, nil | atom},
           ElixirSense.Core.State.Env.t(),
-          ElixirSense.Core.State.mods_funs_to_positions_t(),
-          ElixirSense.Core.State.types_t(),
+          ElixirSense.Core.Compiler.State.mods_funs_to_positions_t(),
+          ElixirSense.Core.Compiler.State.types_t(),
           {pos_integer, pos_integer},
           boolean
         ) :: {nil | module, nil | atom, boolean, nil | :mod_fun | :type}

lib/elixir_sense/core/metadata.ex

@@ -12,19 +12,19 @@ defmodule ElixirSense.Core.Metadata do
 
   @type t :: %ElixirSense.Core.Metadata{
           source: String.t(),
-          mods_funs_to_positions: State.mods_funs_to_positions_t(),
+          mods_funs_to_positions: ElixirSense.Core.Compiler.State.mods_funs_to_positions_t(),
           cursor_env: nil | {keyword(), ElixirSense.Core.State.Env.t()},
           closest_env:
             nil
             | {{pos_integer, pos_integer}, {non_neg_integer, non_neg_integer},
                ElixirSense.Core.State.Env.t()},
-          lines_to_env: State.lines_to_env_t(),
-          calls: State.calls_t(),
-          vars_info_per_scope_id: State.vars_info_per_scope_id_t(),
-          types: State.types_t(),
-          specs: State.specs_t(),
-          structs: State.structs_t(),
-          records: State.records_t(),
+          lines_to_env: ElixirSense.Core.Compiler.State.lines_to_env_t(),
+          calls: ElixirSense.Core.Compiler.State.calls_t(),
+          vars_info_per_scope_id: ElixirSense.Core.Compiler.State.vars_info_per_scope_id_t(),
+          types: ElixirSense.Core.Compiler.State.types_t(),
+          specs: ElixirSense.Core.Compiler.State.specs_t(),
+          structs: ElixirSense.Core.Compiler.State.structs_t(),
+          records: ElixirSense.Core.Compiler.State.records_t(),
           error: nil | term,
           first_alias_positions: map(),
           moduledoc_positions: map()

lib/elixir_sense/core/state/attribute_info.ex

@@ -4,8 +4,8 @@ defmodule ElixirSense.Core.State.AttributeInfo do
   """
   @type t :: %ElixirSense.Core.State.AttributeInfo{
           name: atom,
-          positions: list(ElixirSense.Core.State.position_t()),
-          type: ElixirSense.Core.State.var_type()
+          positions: list(ElixirSense.Core.Compiler.State.position_t()),
+          type: ElixirSense.Core.Compiler.State.var_type()
         }
   defstruct name: nil, positions: [], type: nil
 end

lib/elixir_sense/core/state/env.ex

@@ -7,19 +7,19 @@ defmodule ElixirSense.Core.State.Env do
           functions: [{module, [{atom, arity}]}],
           macros: [{module, [{atom, arity}]}],
           requires: list(module),
-          aliases: list(ElixirSense.Core.State.alias_t()),
+          aliases: list(ElixirSense.Core.Compiler.State.alias_t()),
           macro_aliases: [{module, {term, module}}],
           context: nil | :match | :guard,
           module: nil | module,
           function: nil | {atom, arity},
-          protocol: nil | ElixirSense.Core.State.protocol_t(),
+          protocol: nil | ElixirSense.Core.Compiler.State.protocol_t(),
           versioned_vars: %{optional({atom, atom}) => non_neg_integer},
           vars: list(ElixirSense.Core.State.VarInfo.t()),
           attributes: list(ElixirSense.Core.State.AttributeInfo.t()),
           behaviours: list(module),
           context_modules: list(module),
           typespec: nil | {atom, arity},
-          scope_id: nil | ElixirSense.Core.State.scope_id_t()
+          scope_id: nil | ElixirSense.Core.Compiler.State.scope_id_t()
         }
   defstruct functions: [],
             macros: [],

lib/elixir_sense/core/state/mod_fun_info.ex

@@ -7,8 +7,8 @@ defmodule ElixirSense.Core.State.ModFunInfo do
 
   @type t :: %ElixirSense.Core.State.ModFunInfo{
           params: list(list(term)),
-          positions: list(ElixirSense.Core.State.position_t()),
-          end_positions: list(ElixirSense.Core.State.position_t() | nil),
+          positions: list(ElixirSense.Core.Compiler.State.position_t()),
+          end_positions: list(ElixirSense.Core.Compiler.State.position_t() | nil),
           target: nil | {module, atom},
           overridable: false | {true, module},
           generated: list(boolean),

lib/elixir_sense/core/state/spec_info.ex

@@ -7,8 +7,8 @@ defmodule ElixirSense.Core.State.SpecInfo do
           args: list(list(String.t())),
           specs: [String.t()],
           kind: :spec | :callback | :macrocallback,
-          positions: [ElixirSense.Core.State.position_t()],
-          end_positions: [ElixirSense.Core.State.position_t() | nil],
+          positions: [ElixirSense.Core.Compiler.State.position_t()],
+          end_positions: [ElixirSense.Core.Compiler.State.position_t() | nil],
           doc: String.t(),
           meta: map(),
           generated: list(boolean)

lib/elixir_sense/core/state/type_info.ex

@@ -7,8 +7,8 @@ defmodule ElixirSense.Core.State.TypeInfo do
           args: list(list(String.t())),
           specs: [String.t()],
           kind: :type | :typep | :opaque,
-          positions: [ElixirSense.Core.State.position_t()],
-          end_positions: [ElixirSense.Core.State.position_t() | nil],
+          positions: [ElixirSense.Core.Compiler.State.position_t()],
+          end_positions: [ElixirSense.Core.Compiler.State.position_t() | nil],
           doc: String.t(),
           meta: map(),
           generated: list(boolean)

lib/elixir_sense/core/state/var_info.ex

@@ -5,10 +5,10 @@ defmodule ElixirSense.Core.State.VarInfo do
 
   @type t :: %ElixirSense.Core.State.VarInfo{
           name: atom,
-          positions: list(ElixirSense.Core.State.position_t()),
-          scope_id: nil | ElixirSense.Core.State.scope_id_t(),
+          positions: list(ElixirSense.Core.Compiler.State.position_t()),
+          scope_id: nil | ElixirSense.Core.Compiler.State.scope_id_t(),
           version: non_neg_integer(),
-          type: ElixirSense.Core.State.var_type()
+          type: ElixirSense.Core.Compiler.State.var_type()
         }
   defstruct name: nil,
             positions: [],

lib/elixir_sense/core/struct.ex

@@ -4,14 +4,14 @@ defmodule ElixirSense.Core.Struct do
   alias ElixirSense.Core.Introspection
   alias ElixirSense.Core.State
 
-  @spec is_struct(module | nil, State.structs_t()) :: boolean
+  @spec is_struct(module | nil, ElixirSense.Core.Compiler.State.structs_t()) :: boolean
   def is_struct(nil, _metadata_structs), do: false
 
   def is_struct(module, metadata_structs) do
     Map.has_key?(metadata_structs, module) or Introspection.module_is_struct?(module)
   end
 
-  @spec get_fields(module, State.structs_t()) :: [atom]
+  @spec get_fields(module, ElixirSense.Core.Compiler.State.structs_t()) :: [atom]
   def get_fields(module, metadata_structs) do
     case metadata_structs[module] do
       %State.StructInfo{fields: fields} ->

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

@@ -76,15 +76,6 @@ defmodule ElixirSense.Providers.Completion.Reducers.TypeSpecs do
     end
   end
 
-  defp expand({{:variable, _, _} = type, hint}, env, aliases) do
-    # TODO Binding should return expanded aliases
-    # TODO use Macro.Env
-    case Binding.expand(env, type) do
-      {:atom, module} -> {Introspection.expand_alias(module, aliases), hint}
-      _ -> {nil, ""}
-    end
-  end
-
   defp expand({type, hint}, _env, _aliases) do
     {type, hint}
   end

lib/elixir_sense/providers/completion/suggestion.ex

@@ -103,7 +103,7 @@ defmodule ElixirSense.Providers.Completion.Suggestion do
 
   @add_opts_for [:populate_complete_engine]
 
-  @spec suggestions(String.t(), pos_integer, pos_integer, keyword()) :: [Suggestion.suggestion()]
+  @spec suggestions(String.t(), pos_integer, pos_integer, keyword()) :: [suggestion()]
   def suggestions(code, line, column, options \\ []) do
     {prefix = hint, suffix} = Source.prefix_suffix(code, line, column)