add @impl attributes to behaviour callbacks (elixir-editors#99)

Author: lukaszsamson

apps/debugger/lib/debugger.ex

@@ -5,8 +5,7 @@ defmodule ElixirLS.Debugger do
 
   use Application
 
-  # See http://elixir-lang.org/docs/stable/elixir/Application.html
-  # for more information on OTP Applications
+  @impl Application
   def start(_type, _args) do
     import Supervisor.Spec, warn: false
 
@@ -15,16 +14,14 @@ defmodule ElixirLS.Debugger do
     ElixirLS.Debugger.Output.start(ElixirLS.Debugger.Output)
 
     children = [
-      # Define workers and child supervisors to be supervised
       worker(ElixirLS.Debugger.Server, [[name: ElixirLS.Debugger.Server]])
     ]
 
-    # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
-    # for other strategies and supported options
     opts = [strategy: :one_for_one, name: ElixirLS.Debugger.Supervisor, max_restarts: 0]
     Supervisor.start_link(children, opts)
   end
 
+  @impl Application
   def stop(_state) do
     if ElixirLS.Utils.WireProtocol.io_intercepted?() do
       IO.puts(:standard_error, "ElixirLS debugger has crashed")

apps/debugger/lib/debugger/output.ex

@@ -35,15 +35,18 @@ defmodule ElixirLS.Debugger.Output do
 
   ## Server callbacks
 
+  @impl GenServer
   def init(:ok) do
     {:ok, 1}
   end
 
+  @impl GenServer
   def handle_call({:send_response, request_packet, body}, _from, seq) do
     send(response(seq, request_packet["seq"], request_packet["command"], body))
     {:reply, :ok, seq + 1}
   end
 
+  @impl GenServer
   def handle_call({:send_event, event, body}, _from, seq) do
     send(event(seq, event, body))
     {:reply, :ok, seq + 1}

apps/debugger/lib/debugger/server.ex

@@ -52,18 +52,21 @@ defmodule ElixirLS.Debugger.Server do
 
   ## Server Callbacks
 
+  @impl GenServer
   def init(opts) do
     :int.start()
     state = if opts[:output], do: %__MODULE__{output: opts[:output]}, else: %__MODULE__{}
     {:ok, state}
   end
 
+  @impl GenServer
   def handle_cast({:receive_packet, request(_, _) = packet}, state) do
     {response_body, state} = handle_request(packet, state)
     Output.send_response(packet, response_body)
     {:noreply, state}
   end
 
+  @impl GenServer
   def handle_cast({:breakpoint_reached, pid}, state) do
     {state, thread_id} = ensure_thread_id(state, pid)
 
@@ -76,6 +79,7 @@ defmodule ElixirLS.Debugger.Server do
     {:noreply, state}
   end
 
+  @impl GenServer
   def handle_info({:DOWN, ref, :process, _pid, reason}, %{task_ref: ref} = state) do
     exit_code =
       case reason do
@@ -97,17 +101,20 @@ defmodule ElixirLS.Debugger.Server do
     {:noreply, %{state | task_ref: nil}}
   end
 
+  @impl GenServer
   def handle_info({:EXIT, _, :normal}, state) do
     {:noreply, state}
   end
 
   # If we get the disconnect request from the client, we send :disconnect to the server so it will
   # die right after responding to the request
+  @impl GenServer
   def handle_info(:disconnect, state) do
     System.halt(0)
     {:noreply, state}
   end
 
+  @impl GenServer
   def terminate(reason, _state) do
     if reason != :normal do
       IO.puts(:standard_error, "(Debugger) Terminating because #{Exception.format_exit(reason)}")

apps/elixir_ls_utils/lib/mix.tasks.elixir_ls.release.ex

@@ -1,7 +1,10 @@
 defmodule Mix.Tasks.ElixirLs.Release do
+  use Mix.Task
+
   @switches [destination: :string, zip: :string]
   @aliases [o: :destination, z: :zip]
 
+  @impl Mix.Task
   def run(args) do
     version_warning()
     {opts, _} = OptionParser.parse!(args, aliases: @aliases, switches: @switches)

apps/elixir_ls_utils/lib/output_device.ex

@@ -20,30 +20,36 @@ defmodule ElixirLS.Utils.OutputDevice do
 
   ## Server callbacks
 
+  @impl GenServer
   def init({device, output_fn}) do
     {:ok, {device, output_fn}}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:put_chars, _encoding, characters}}, s) do
     output(from, reply_as, characters, s)
     {:noreply, s}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:put_chars, characters}}, s) do
     output(from, reply_as, characters, s)
     {:noreply, s}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:put_chars, _encoding, module, func, args}}, s) do
     output(from, reply_as, apply(module, func, args), s)
     {:noreply, s}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:put_chars, module, func, args}}, s) do
     output(from, reply_as, apply(module, func, args), s)
     {:noreply, s}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:requests, reqs}}, s) do
     for req <- reqs do
       handle_info({:io_request, from, reply_as, req}, s)
@@ -53,6 +59,7 @@ defmodule ElixirLS.Utils.OutputDevice do
   end
 
   # Any other message (get_geometry, set_opts, etc.) goes directly to original device
+  @impl GenServer
   def handle_info(msg, {device, _} = s) do
     send(device, msg)
     {:noreply, s}

apps/elixir_ls_utils/test/support/packet_capture.ex

@@ -16,14 +16,17 @@ defmodule ElixirLS.Utils.PacketCapture do
 
   ## Server Callbacks
 
+  @impl GenServer
   def init(parent) do
     {:ok, parent}
   end
 
+  @impl GenServer
   def handle_info({:io_request, from, reply_as, {:put_chars, _encoding, chars}}, parent) do
     handle_output(to_string(chars), from, reply_as, parent)
   end
 
+  @impl GenServer
   def handle_info(
         {:io_request, from, reply_as, {:put_chars, _encoding, module, fun, args}},
         parent

apps/language_server/lib/language_server.ex

@@ -5,23 +5,20 @@ defmodule ElixirLS.LanguageServer do
   require Logger
   use Application
 
-  # See http://elixir-lang.org/docs/stable/elixir/Application.html
-  # for more information on OTP Applications
+  @impl Application
   def start(_type, _args) do
     import Supervisor.Spec, warn: false
 
     children = [
-      # Define workers and child supervisors to be supervised
       worker(ElixirLS.LanguageServer.Server, [ElixirLS.LanguageServer.Server]),
       worker(ElixirLS.LanguageServer.JsonRpc, [[name: ElixirLS.LanguageServer.JsonRpc]])
     ]
 
-    # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
-    # for other strategies and supported options
     opts = [strategy: :one_for_one, name: ElixirLS.LanguageServer.Supervisor, max_restarts: 0]
     Supervisor.start_link(children, opts)
   end
 
+  @impl Application
   def stop(_state) do
     if ElixirLS.Utils.WireProtocol.io_intercepted?() do
       ElixirLS.LanguageServer.JsonRpc.show_message(

apps/language_server/lib/language_server/dialyzer.ex

@@ -94,6 +94,7 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
 
   # Server callbacks
 
+  @impl GenServer
   def init({parent, root_path}) do
     state = %__MODULE__{parent: parent, root_path: root_path}
 
@@ -117,6 +118,7 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
     {:ok, state}
   end
 
+  @impl GenServer
   def handle_call(
         {:analysis_finished, _status, active_plt, mod_deps, md5, warnings, timestamp, build_ref},
         _from,
@@ -147,11 +149,13 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
     {:reply, :ok, state}
   end
 
+  @impl GenServer
   def handle_call({:suggest_contracts, files}, _from, %{plt: plt} = state) do
     specs = if is_nil(plt), do: [], else: SuccessTypings.suggest_contracts(plt, files)
     {:reply, specs, state}
   end
 
+  @impl GenServer
   def handle_cast({:analyze, build_ref, warn_opts, warning_format}, state) do
     state =
       ElixirLS.LanguageServer.Build.with_build_lock(fn ->
@@ -181,10 +185,12 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
     {:noreply, state}
   end
 
+  @impl GenServer
   def handle_info({:"ETS-TRANSFER", _, _, _}, state) do
     {:noreply, state}
   end
 
+  @impl GenServer
   def terminate(reason, _state) do
     if reason != :normal do
       JsonRpc.show_message(

apps/language_server/lib/language_server/dialyzer/supervisor.ex

@@ -6,6 +6,7 @@ defmodule ElixirLS.LanguageServer.Dialyzer.Supervisor do
     Supervisor.start_link(__MODULE__, {parent, root_path})
   end
 
+  @impl Supervisor
   def init({parent, root_path}) do
     Supervisor.init(
       [

apps/language_server/lib/language_server/json_rpc.ex

@@ -123,6 +123,7 @@ defmodule ElixirLS.LanguageServer.JsonRpc do
 
   ## Server callbacks
 
+  @impl GenServer
   def init(opts) do
     state =
       if language_server = opts[:language_server] do
@@ -134,30 +135,35 @@ defmodule ElixirLS.LanguageServer.JsonRpc do
     {:ok, state}
   end
 
+  @impl GenServer
   def handle_call({:packet, notification(_) = packet}, _from, state) do
     ElixirLS.LanguageServer.Server.receive_packet(packet)
     {:reply, :ok, state}
   end
 
+  @impl GenServer
   def handle_call({:packet, request(_, _, _) = packet}, _from, state) do
     ElixirLS.LanguageServer.Server.receive_packet(packet)
     {:reply, :ok, state}
   end
 
+  @impl GenServer
   def handle_call({:packet, response(id, result)}, _from, state) do
     %{^id => from} = state.outgoing_requests
     GenServer.reply(from, {:ok, result})
     state = update_in(state.outgoing_requests, &Map.delete(&1, id))
     {:reply, :ok, state}
   end
 
+  @impl GenServer
   def handle_call({:packet, error_response(id, code, message)}, _from, state) do
     %{^id => from} = state.outgoing_requests
     GenServer.reply(from, {:error, code, message})
     state = update_in(state.outgoing_requests, &Map.delete(&1, id))
     {:reply, :ok, state}
   end
 
+  @impl GenServer
   def handle_call({:request, method, params}, from, state) do
     send(request(state.next_id, method, params))
     state = update_in(state.outgoing_requests, &Map.put(&1, state.next_id, from))

apps/language_server/lib/language_server/mix_shell.ex

@@ -9,11 +9,19 @@ defmodule ElixirLS.LanguageServer.MixShell do
 
   @behaviour Mix.Shell
 
-  defdelegate(print_app, to: Mix.Shell.IO)
-  defdelegate(cmd(command, opts \\ []), to: Mix.Shell.IO)
-  defdelegate(info(message), to: Mix.Shell.IO)
-  defdelegate(error(message), to: Mix.Shell.IO)
+  @impl Mix.Shell
+  defdelegate print_app, to: Mix.Shell.IO
 
+  @impl Mix.Shell
+  defdelegate cmd(command, opts \\ []), to: Mix.Shell.IO
+
+  @impl Mix.Shell
+  defdelegate info(message), to: Mix.Shell.IO
+
+  @impl Mix.Shell
+  defdelegate error(message), to: Mix.Shell.IO
+
+  @impl Mix.Shell
   def prompt(message) do
     if WireProtocol.io_intercepted?() do
       IO.puts(message)
@@ -29,6 +37,7 @@ defmodule ElixirLS.LanguageServer.MixShell do
     end
   end
 
+  @impl Mix.Shell
   def yes?(message) do
     if WireProtocol.io_intercepted?() do
       response =