Type checking of :into

Author: josevalim

lib/elixir/lib/calendar/date.ex

@@ -188,9 +188,8 @@ defmodule Date do
   end
 
   def utc_today(calendar) do
-    calendar
-    |> DateTime.utc_now()
-    |> DateTime.to_date()
+    %{year: year, month: month, day: day} = DateTime.utc_now(calendar)
+    %Date{year: year, month: month, day: day, calendar: calendar}
   end
 
   @doc """

lib/elixir/lib/module/types/apply.ex

@@ -838,6 +838,15 @@ defmodule Module.Types.Apply do
            it has type:
            """, [:generator], collect_traces(arg, context)}
 
+        :into ->
+          {"""
+           incompatible value given to :into option in for-comprehension:
+
+               into: #{expr_to_string(expr) |> indent(4)}
+
+           it has type:
+           """, [:into], collect_traces(expr, context)}
+
         _ ->
           mfa_or_fa = if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
 

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

@@ -338,10 +338,10 @@ defmodule Module.Types.Expr do
   end
 
   # TODO: for pat <- expr do expr end
-  def of_expr({:for, _meta, [_ | _] = args}, stack, context) do
+  def of_expr({:for, meta, [_ | _] = args}, stack, context) do
     {clauses, [[{:do, block} | opts]]} = Enum.split(args, -1)
     context = Enum.reduce(clauses, context, &for_clause(&1, stack, &2))
-    context = Enum.reduce(opts, context, &for_option(&1, stack, &2))
+    context = Enum.reduce(opts, context, &for_option(&1, meta, stack, &2))
 
     if Keyword.has_key?(opts, :reduce) do
       {_, context} = of_clauses(block, [dynamic()], :for_reduce, stack, {none(), context})
@@ -504,17 +504,29 @@ defmodule Module.Types.Expr do
     context
   end
 
-  defp for_option({:into, expr}, stack, context) do
-    {_type, context} = of_expr(expr, stack, context)
+  defp for_option({:into, expr}, meta, stack, context) do
+    {type, context} = of_expr(expr, stack, context)
+
+    meta =
+      case expr do
+        {_, meta, _} -> meta
+        _ -> meta
+      end
+
+    wrapped_expr = {:__block__, [type_check: :into] ++ meta, [expr]}
+
+    {_type, context} =
+      Apply.remote(Collectable, :into, [expr], [type], wrapped_expr, stack, context)
+
     context
   end
 
-  defp for_option({:reduce, expr}, stack, context) do
+  defp for_option({:reduce, expr}, _meta, stack, context) do
     {_type, context} = of_expr(expr, stack, context)
     context
   end
 
-  defp for_option({:uniq, _}, _stack, context) do
+  defp for_option({:uniq, _}, _meta, _stack, context) do
     # This option is verified to be a boolean at compile-time
     context
   end

lib/elixir/lib/module/types/helpers.ex

@@ -85,19 +85,26 @@ defmodule Module.Types.Helpers do
       :interpolation ->
         """
 
-        #{hint()} string interpolation in Elixir uses the String.Chars protocol to \
+        #{hint()} string interpolation uses the String.Chars protocol to \
         convert a data structure into a string. Either convert the data type into a \
         string upfront or implement the protocol accordingly
         """
 
       :generator ->
         """
 
-        #{hint()} for-comprehensions in Elixir use the Enumerable protocol to traverse \
+        #{hint()} for-comprehensions use the Enumerable protocol to traverse \
         data structures. Either convert the data type into a list (or another Enumerable) \
         or implement the protocol accordingly
         """
 
+      :into ->
+        """
+
+        #{hint()} the :into option in for-comprehensions use the Enumerable protocol to \
+        build its result. Either pass a valid data type or implement the protocol accordingly
+        """
+
       :anonymous_rescue ->
         """
 

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

@@ -405,7 +405,7 @@ defmodule Module.Types.IntegrationTest do
                 # from: a.ex:3:24
                 _.._//_ = data
 
-            hint: string interpolation in Elixir uses the String.Chars protocol to convert a data structure into a string. Either convert the data type into a string upfront or implement the protocol accordingly
+            hint: string interpolation uses the String.Chars protocol to convert a data structure into a string. Either convert the data type into a string upfront or implement the protocol accordingly
         """,
         """
             warning: incompatible types given to String.Chars.to_string/1:
@@ -437,6 +437,8 @@ defmodule Module.Types.IntegrationTest do
         "a.ex" => """
         defmodule FooBar do
           def example1(%Date{} = date), do: for(x <- date, do: x)
+          def example2(), do: for(i <- [1, 2, 3], into: Date.utc_today(), do: i * 2)
+          def example3(), do: for(i <- [1, 2, 3], into: 456, do: i * 2)
         end
         """
       }
@@ -462,7 +464,42 @@ defmodule Module.Types.IntegrationTest do
                 # from: a.ex:2:24
                 %Date{} = date
 
-            hint: for-comprehensions in Elixir use the Enumerable protocol to traverse data structures. Either convert the data type into a list (or another Enumerable) or implement the protocol accordingly
+            hint: for-comprehensions use the Enumerable protocol to traverse data structures. Either convert the data type into a list (or another Enumerable) or implement the protocol accordingly
+        """,
+        """
+            warning: incompatible value given to :into option in for-comprehension:
+
+                into: Date.utc_today()
+
+            it has type:
+
+                -dynamic(
+                  %Date{year: term(), month: integer(), day: float() or integer(), calendar: Calendar.ISO} or
+                    %Date{year: term(), month: term(), day: term(), calendar: term()}
+                )-
+
+            but expected a type that implements the Collectable protocol, it must be one of:
+
+                %File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{} or binary() or
+                  list(term()) or non_struct_map()
+
+            hint: the :into option in for-comprehensions use the Enumerable protocol to build its result. Either pass a valid data type or implement the protocol accordingly
+        """,
+        """
+            warning: incompatible value given to :into option in for-comprehension:
+
+                into: 456
+
+            it has type:
+
+                -integer()-
+
+            but expected a type that implements the Collectable protocol, it must be one of:
+
+                %File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{} or binary() or
+                  list(term()) or non_struct_map()
+
+            hint: the :into option in for-comprehensions use the Enumerable protocol to build its result. Either pass a valid data type or implement the protocol accordingly
         """
       ]