Fix incorrect narrowing in mixed type for into

Closes #15950.
Closes #15952.

Assisted-by: Codex:GPT-6

Author: lukaszsamson

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

@@ -629,18 +629,16 @@ defmodule Module.Types.Expr do
           if :bitstring in into_kinds do
             intersection = opt_intersection(block_type, bitstring())
 
-            # TODO: currently if :into is a binary, then we expect the body
-            # to return a binary, even if the binary is a gradual type. This
-            # is ok for now because we only check for bitstring if the type
-            # is a subset of empty_list() or bitstring(), but we may want to
-            # relax in the future.
-            if empty?(intersection) do
-              error = {:badbitbody, block_type, block, context}
-              {error_type(), error(__MODULE__, error, meta, stack, context)}
-            else
+            # On the binary path the body must be a bitstring. If the collectable
+            # is compatible with a list, that path may never happen, so we accept.
+            if compatible?(block_type, bitstring()) or
+                 (:non_empty_list in into_kinds and compatible?(into_type, empty_list())) do
               # If into_type is a binary but the block is a bitstring_no_binary(),
               # then the result may be a bitstring_no_binary().
-              {opt_union(intersection, result_type), context}
+              {opt_union(intersection, opt_union(result_type, binary())), context}
+            else
+              error = {:badbitbody, block_type, block, context}
+              {error_type(), error(__MODULE__, error, meta, stack, context)}
             end
           else
             {result_type, context}
@@ -863,19 +861,23 @@ defmodule Module.Types.Expr do
     # We use subtype? instead of compatible because we want to handle
     # only bitstring/list, even if a dynamic with something else is given.
     if subtype?(type, @into_compile) do
-      cond do
-        bitstring_type?(type) ->
-          kinds = if empty_list_type?(type), do: [:bitstring, :non_empty_list], else: [:bitstring]
-          # A comprehension may concatenate the block an arbitrary number of times.
-          # Even if both the initial value and each block are unaligned bitstrings,
-          # repeated concatenation may eventually produce an aligned binary.
-          {kinds, opt_union(binary(), type), bitstring(), context}
-
-        empty_list_type?(type) ->
+      # A comprehension may concatenate the block an arbitrary number of times.
+      # Even if both the initial value and each block are unaligned bitstrings,
+      # repeated concatenation may eventually produce an aligned binary.
+      case {bitstring_type?(type), empty_list_type?(type)} do
+        # The collectable may be a list, which accepts any element, so the
+        # body is not restricted. The caller checks the binary path.
+        {true, true} ->
+          {[:bitstring, :non_empty_list], type, term(), context}
+
+        {true, false} ->
+          {[:bitstring], type, bitstring(), context}
+
+        {false, true} ->
           {[:non_empty_list], type, maybe_list_hd_or_term(expected), context}
 
         # The type is empty...
-        true ->
+        {false, false} ->
           {[], type, term(), context}
       end
     else

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

@@ -3576,6 +3576,22 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([enum, other], for(x <- enum, do: x, into: other)) == dynamic()
     end
 
+    test ":into bitstrings" do
+      assert typecheck!([items], for(_ <- items, into: <<0::4>>, do: <<1::4>>)) == bitstring()
+
+      assert typecheck!(
+               [items],
+               (
+                 bits = for _ <- items, into: <<0::4>>, do: <<1::4>>
+
+                 case bits do
+                   x when is_binary(x) -> :binary
+                   _ -> :bits
+                 end
+               )
+             ) == atom([:binary, :bits])
+    end
+
     test ":into unions" do
       assert typecheck!(
                [binary],
@@ -3595,22 +3611,18 @@ defmodule Module.Types.ExprTest do
                dynamic(
                  opt_union(opt_union(bitstring(), empty_list()), list(bitstring_no_binary()))
                )
-    end
-
-    test ":into bitstrings" do
-      assert typecheck!([items], for(_ <- items, into: <<0::4>>, do: <<1::4>>)) == bitstring()
 
       assert typecheck!(
-               [items],
+               [value],
                (
-                 bits = for _ <- items, into: <<0::4>>, do: <<1::4>>
-
-                 case bits do
-                   x when is_binary(x) -> :binary
-                   _ -> :bits
-                 end
+                 into = if :rand.uniform() > 0.5, do: [], else: ""
+                 for(_ <- [1], do: value, into: into)
+               )
+             ) ==
+               opt_union(
+                 dynamic(opt_union(bitstring_no_binary(), non_empty_list(term()))),
+                 opt_union(binary(), empty_list())
                )
-             ) == atom([:binary, :bits])
     end
 
     test ":into inference" do
@@ -3647,6 +3659,77 @@ defmodule Module.Types.ExprTest do
                  # from: types_test.ex:LINE
                  <<x>>
              """
+
+      # In static mode the body must be a bitstring whenever the target may be a binary
+      assert typeerror!(
+               [flag],
+               (
+                 into = if flag, do: [], else: ""
+                 value = if flag, do: :ok, else: "ok"
+                 for(_ <- [1], do: value, into: into)
+               )
+             ) =~ ~l"""
+             expected the body of a for-comprehension with into: binary() (or bitstring()) to be a binary (or bitstring):
+
+                 value
+
+             but got type:
+
+                 :ok or binary()
+             """
+
+      assert typeerror!(
+               [flag],
+               (
+                 into = if flag, do: [], else: ""
+                 for(_ <- [1], do: :ok, into: into)
+               )
+             ) =~ ~l"""
+             expected the body of a for-comprehension with into: binary() (or bitstring()) to be a binary (or bitstring):
+
+                 :ok
+
+             but got type:
+
+                 :ok
+             """
+
+      assert typeerror!(
+               [flag],
+               (
+                 value = if flag, do: :ok, else: "ok"
+                 for(_ <- [1], do: value, into: "")
+               )
+             ) =~ ~l"""
+             expected the body of a for-comprehension with into: binary() (or bitstring()) to be a binary (or bitstring):
+
+                 value
+
+             but got type:
+
+                 :ok or binary()
+             """
+    end
+
+    test ":into dynamic" do
+      # In dynamic mode the list path may succeed, so the body is not restricted
+      # to bitstrings and the list result keeps the full element type
+      assert typedyn!(
+               [flag],
+               (
+                 into = if flag, do: [], else: ""
+                 value = if flag, do: :ok, else: "ok"
+                 for(_ <- [1], do: value, into: into)
+               )
+             ) == dynamic(opt_union(binary(), list(opt_union(atom([:ok]), binary()))))
+
+      assert typedyn!(
+               [flag],
+               (
+                 into = if flag, do: [], else: ""
+                 for(_ <- [1], do: :ok, into: into)
+               )
+             ) == dynamic(opt_union(binary(), list(atom([:ok]))))
     end
 
     test ":into with non-returning collectable" do