Update to elixir 1.19 (#1038)

* Start satisfying credo

* Satisfy credo

* Satisfy the compiler

* Fix cp_r

* Disable dialyzer opaque checks

* Remove commented code

* Apply reviewers suggestions

* Improve comments

Author: Noarkhh

lib/membrane/children_spec.ex

@@ -452,7 +452,9 @@ defmodule Membrane.ChildrenSpec do
       via_in(builder, :input)
     end
     |> Builder.finish_link(child_name)
-    |> then(&%Builder{&1 | children: [child_spec | &1.children]})
+    |> then(fn %Builder{} = builder ->
+      %Builder{builder | children: [child_spec | builder.children]}
+    end)
   end
 
   @doc """
@@ -465,7 +467,9 @@ defmodule Membrane.ChildrenSpec do
     :ok = validate_pad_name(pad)
 
     get_child({Membrane.Bin, :itself})
-    |> then(&%Builder{&1 | status: :from_pad, from_pad: pad, from_pad_props: %{}})
+    |> then(fn %Builder{} = builder ->
+      %Builder{builder | status: :from_pad, from_pad: pad, from_pad_props: %{}}
+    end)
   end
 
   @doc """
@@ -488,7 +492,9 @@ defmodule Membrane.ChildrenSpec do
     else
       via_out(builder, :output)
     end
-    |> then(&%Builder{&1 | status: :to_pad, to_pad: pad, to_pad_props: %{}})
+    |> then(fn %Builder{} = builder ->
+      %Builder{builder | status: :to_pad, to_pad: pad, to_pad_props: %{}}
+    end)
     |> get_child({Membrane.Bin, :itself})
   end
 
@@ -541,7 +547,7 @@ defmodule Membrane.ChildrenSpec do
           "Invalid link specification: input #{inspect(pad)} placed after another input"
   end
 
-  def via_in(%Builder{links: [%{to: {Membrane.Bin, :itself}} | _]}, pad, _props) do
+  def via_in(%Builder{links: [%{to: {Membrane.Bin, :itself}} | _rest]}, pad, _props) do
     raise ParentError,
           "Invalid link specification: input #{inspect(pad)} placed after bin's output"
   end
@@ -572,7 +578,9 @@ defmodule Membrane.ChildrenSpec do
     else
       via_out(builder, :output)
     end
-    |> then(&%Builder{&1 | status: :to_pad, to_pad: pad, to_pad_props: Enum.into(props, %{})})
+    |> then(fn %Builder{} = builder ->
+      %Builder{builder | status: :to_pad, to_pad: pad, to_pad_props: Enum.into(props, %{})}
+    end)
   end
 
   @doc """
@@ -598,7 +606,7 @@ defmodule Membrane.ChildrenSpec do
     raise ParentError, "Invalid link specification: output #{inspect(pad)} placed after an input"
   end
 
-  def via_out(%Builder{links: [%{to: {Membrane.Bin, :itself}} | _]}, pad, _props) do
+  def via_out(%Builder{links: [%{to: {Membrane.Bin, :itself}} | _rest]}, pad, _props) do
     raise ParentError,
           "Invalid link specification: output #{inspect(pad)} placed after bin's output"
   end

lib/membrane/core/child/pad_controller.ex

@@ -61,7 +61,7 @@ defmodule Membrane.Core.Child.PadController do
           map | no_return
   def parse_pad_options!(pad_name, options, state) do
     {_pad_name, pad_spec} =
-      PadSpecHandler.get_pads(state) |> Enum.find(fn {k, _} -> k == pad_name end)
+      PadSpecHandler.get_pads(state) |> Enum.find(fn {k, _desc} -> k == pad_name end)
 
     bunch_field_specs =
       Bunch.KVList.map_values(pad_spec.options || [], &Keyword.take(&1, [:default]))

lib/membrane/core/child/pads_specs.ex

@@ -340,7 +340,7 @@ defmodule Membrane.Core.Child.PadsSpecs do
   def generate_docs_from_pads_specs(pads_specs) do
     pads_docs =
       pads_specs
-      |> Enum.sort_by(fn {_, config} -> config[:direction] end)
+      |> Enum.sort_by(fn {_pad_name, config} -> config[:direction] end)
       |> Enum.map(&generate_docs_from_pad_specs/1)
       |> Enum.reduce(fn x, acc ->
         quote do

lib/membrane/core/element.ex

@@ -102,6 +102,10 @@ defmodule Membrane.Core.Element do
     end
   end
 
+  # Suppress false positive dialyzer warnings resulting from 
+  # broken handling of opaque types - in this case MapSet.t() 
+  # https://github.com/elixir-lang/elixir/issues/14576
+  @dialyzer {:nowarn_function, do_init: 1}
   defp do_init(options) do
     Process.link(options.parent_supervisor)
 
@@ -141,9 +145,9 @@ defmodule Membrane.Core.Element do
     state =
       %State{
         module: options.module,
-        type: options.module.membrane_element_type(),
         name: options.name,
         parent_pid: options.parent,
+        type: options.module.membrane_element_type(),
         synchronization: %{
           parent_clock: options.parent_clock,
           timers: %{},

lib/membrane/core/element/action_handler.ex

@@ -75,13 +75,13 @@ defmodule Membrane.Core.Element.ActionHandler do
   end
 
   @impl CallbackHandler
-  def handle_action({action, _}, :handle_init, _params, _state)
+  def handle_action({action, _arg}, :handle_init, _params, _state)
       when action not in [:latency, :notify_parent] do
     raise ActionError, action: action, reason: {:invalid_callback, :handle_init}
   end
 
   @impl CallbackHandler
-  def handle_action({action, _}, _cb, _params, %State{playback: playback})
+  def handle_action({action, _arg}, _cb, _params, %State{playback: playback})
       when playback != :playing and
              action in [
                :buffer,
@@ -291,12 +291,13 @@ defmodule Membrane.Core.Element.ActionHandler do
     actions
     |> Bunch.Enum.chunk_by_prev(
       fn
-        {:buffer, {pad, _}}, {:buffer, {pad, _}} -> true
+        {:buffer, {pad, _buffer1}}, {:buffer, {pad, _buffer2}} -> true
         _prev_action, _action -> false
       end,
       fn
-        [{:buffer, {pad, _}} | _] = buffers ->
-          {:buffer, {pad, buffers |> Enum.map(fn {_, {_, b}} -> [b] end) |> List.flatten()}}
+        [{:buffer, {pad, _buffer}} | _rest] = buffers ->
+          {:buffer,
+           {pad, buffers |> Enum.map(fn {:buffer, {_pad, b}} -> [b] end) |> List.flatten()}}
 
         [other] ->
           other

lib/membrane/core/element/auto_flow_controller.ex

@@ -218,6 +218,10 @@ defmodule Membrane.Core.Element.AutoFlowController do
     |> Map.put(:popping_auto_flow_queue?, false)
   end
 
+  # Suppress false positive dialyzer warnings resulting from 
+  # broken handling of opaque types - in this case MapSet.t() 
+  # https://github.com/elixir-lang/elixir/issues/14576
+  @dialyzer {:nowarn_function, bump_demand: 1}
   defp bump_demand(state) do
     if state.effective_flow_control == :pull and
          state.satisfied_auto_output_pads == @empty_map_set do

lib/membrane/core/element/event_controller.ex

@@ -5,7 +5,6 @@ defmodule Membrane.Core.Element.EventController do
 
   use Bunch
 
-  alias Membrane.{Event, Pad, Sync}
   alias Membrane.Core.{CallbackHandler, Events, Message, Telemetry}
   alias Membrane.Core.Child.PadModel
 
@@ -19,6 +18,7 @@ defmodule Membrane.Core.Element.EventController do
   }
 
   alias Membrane.Core.Element.ManualFlowController.InputQueue
+  alias Membrane.{Event, Pad, Sync}
 
   require Membrane.Core.Child.PadModel
   require Membrane.Core.Message

lib/membrane/core/element/lifecycle_controller.ex

@@ -73,7 +73,7 @@ defmodule Membrane.Core.Element.LifecycleController do
   end
 
   @spec handle_playing(State.t()) :: State.t()
-  def handle_playing(state) do
+  def handle_playing(%State{} = state) do
     Membrane.Logger.debug("Got play request")
 
     state =

lib/membrane/core/element/manual_flow_controller.ex

@@ -80,7 +80,7 @@ defmodule Membrane.Core.Element.ManualFlowController do
     |> handle_delayed_demands()
   end
 
-  defp do_supply_demand(pad_ref, state) do
+  defp do_supply_demand(pad_ref, %State{} = state) do
     # marking is state that actual demand supply has been started (note changing back to false when finished)
     state = %State{state | delay_demands?: true}
 
@@ -90,7 +90,7 @@ defmodule Membrane.Core.Element.ManualFlowController do
       InputQueue.take(pad_data.input_queue, pad_data.manual_demand_size)
 
     state = PadModel.set_data!(state, pad_ref, :input_queue, new_input_queue)
-    state = handle_input_queue_output(pad_ref, popped_data, state)
+    %State{} = state = handle_input_queue_output(pad_ref, popped_data, state)
     %State{state | delay_demands?: false}
   end
 

lib/membrane/core/element/playback_queue.ex

@@ -12,7 +12,8 @@ defmodule Membrane.Core.Element.PlaybackQueue do
 
   @spec eval(State.t()) :: State.t()
   def eval(%State{playback_queue: playback_queue} = state) do
-    state =
+    %State{} =
+      state =
       playback_queue
       |> List.foldr(state, fn function, state -> function.(state) end)