Perform reverse arrows on with even when not precise

Author: josevalim

lib/elixir/lib/module/types/expr.ex

@@ -768,17 +768,13 @@ defmodule Module.Types.Expr do
     {trees, precise?, context} =
       Pattern.of_generator(pattern, guards, type, :with, expr, meta, stack, context)
 
-    if precise? do
-      [pattern_type] = Pattern.of_domain(trees, stack, context)
+    [pattern_type] = Pattern.of_domain(trees, stack, context)
 
-      {_, refined_context} =
-        of_expr(right, pattern_type, right, %{stack | reverse_arrow: :use}, context)
+    {_, refined_context} =
+      of_expr(right, pattern_type, right, %{stack | reverse_arrow: :use}, context)
 
-      {union(difference(type, pattern_type), else_types),
-       reset_warnings(refined_context, context)}
-    else
-      {union(type, else_types), context}
-    end
+    else_type = if precise?, do: difference(type, pattern_type), else: type
+    {union(else_type, else_types), reset_warnings(refined_context, context)}
   end
 
   defp with_clause(expr, stack, {else_types, context}) do

lib/elixir/lib/module/types/pattern.ex

@@ -342,7 +342,7 @@ defmodule Module.Types.Pattern do
            of_pattern_refine(types, changed, pattern_info, tag, stack, context) do
       {args, pattern_precise? and guard_precise?, context}
     else
-      {:error, context} -> {tree, false, context}
+      {:error, context} -> {args, false, context}
     end
   end
 

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -2711,6 +2711,23 @@ defmodule Module.Types.ExprTest do
              ) ==
                dynamic(union(binary(), atom([nil, :not_precise])))
                |> union(atom([:not_precise]))
+
+      assert typecheck!(
+               [x],
+               with :ok <- System.get_env(x) && :ok do
+                 {:ok, x}
+               end
+             ) ==
+               dynamic(union(tuple([atom([:ok]), binary()]), atom([nil])))
+
+      assert typecheck!(
+               [x],
+               with {:ok, "not precise"} <- if(y = System.get_env(x), do: {:ok, y}) do
+                 {:ok, x}
+               end
+             ) ==
+               dynamic(union(tuple([atom([:ok]), binary()]), atom([nil])))
+               |> union(atom([nil]))
     end
 
     test "warns on non-matching generators" do