Remove dialyzer warnings from else in with clauses (#7031)

Add generated: true to guard clauses from else in with clauses

Resolves #6426

Author: ggcampinho

lib/elixir/src/elixir_erl_pass.erl

@@ -371,11 +371,31 @@ translate_with_else(Meta, [{else, Else}], S) ->
   RaiseExpr = {{'.', Generated, [erlang, error]}, Generated, [{with_clause, RaiseVar}]},
   RaiseClause = {'->', Generated, [[RaiseVar], RaiseExpr]},
 
-  GeneratedElse = [{'->', ?generated(ElseMeta), ElseArgs} || {'->', ElseMeta, ElseArgs} <- Else],
+  GeneratedElse = [build_generated_clause(Generated, ElseClause) || ElseClause <- Else],
+
   Case = {'case', [{export_vars, false} | Generated], [ElseVarEx, [{do, GeneratedElse ++ [RaiseClause]}]]},
   {TranslatedCase, SC} = elixir_erl_pass:translate(Case, SV),
   {{clause, ?ann(Generated), [ElseVarErl], [], [TranslatedCase]}, SC}.
 
+build_generated_clause(Generated, {'->', _, [Args, Clause]}) ->
+  NewArgs = [build_generated_clause_arg(Generated, Arg) || Arg <- Args],
+  {'->', Generated, [NewArgs, Clause]}.
+
+build_generated_clause_arg(Generated, Arg) ->
+  {Expr, Guards} = elixir_utils:extract_guards(Arg),
+  NewGuards = [build_generated_guard(Generated, Guard) || Guard <- Guards],
+  concat_guards(Generated, Expr, NewGuards).
+
+build_generated_guard(Generated, {{'.', _, _} = Call, _, Args}) ->
+  {Call, Generated, [build_generated_guard(Generated, Arg) || Arg <- Args]};
+build_generated_guard(_, Expr) ->
+  Expr.
+
+concat_guards(_Meta, Expr, []) ->
+  Expr;
+concat_guards(Meta, Expr, [Guard | Tail]) ->
+  {'when', Meta, [Expr, concat_guards(Meta, Guard, Tail)]}.
+
 translate_with_do([{'<-', Meta, [Left, Expr]} | Rest], Do, Else, S) ->
   {Args, Guards} = elixir_utils:extract_guards(Left),
   {TExpr, SR} = elixir_erl_pass:translate(Expr, S),

lib/elixir/test/elixir/fixtures/dialyzer/with.ex

@@ -1,13 +1,25 @@
 defmodule Dialyzer.With do
   def with_else do
     with :ok <- ok_or_error(),
-         :ok <- ok_or_other_error() do
+         :ok <- ok_or_other_error(),
+         :ok <- ok_or_tuple_error(),
+         :ok <- ok_or_tuple_list_error() do
       :ok
     else
       :error ->
         :error
+
       :other_error ->
         :other_error
+
+      {:error, msg} when is_list(msg) or is_tuple(msg) ->
+        :error
+
+      {:error, msg} when is_list(msg) when is_tuple(msg) ->
+        :error
+
+      {:error, _msg} ->
+        :error
     end
   end
 
@@ -20,4 +32,14 @@ defmodule Dialyzer.With do
   defp ok_or_other_error do
     Enum.random([:ok, :other_error])
   end
+
+  @spec ok_or_tuple_error() :: :ok | {:error, :err}
+  defp ok_or_tuple_error do
+    Enum.random([:ok, {:error, :err}])
+  end
+
+  @spec ok_or_tuple_list_error() :: :ok | {:error, [:err]}
+  defp ok_or_tuple_list_error do
+    Enum.random([:ok, {:error, [:err]}])
+  end
 end