More tests

Author: josevalim

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

@@ -360,7 +360,7 @@ defmodule Module.Types.Expr do
         {timeout_type, context} = of_expr(timeout, {@timeout_type, after_expr}, stack, context)
         {body_type, context} = of_expr(body, expected_expr, stack, context)
 
-        if compatible?(timeout_type, @timeout_type) do
+        if integer_type?(timeout_type) or atom_type?(timeout_type, :infinity) do
           {union(body_type, acc), reset_vars(context, original)}
         else
           error = {:badtimeout, timeout_type, timeout, context}
@@ -620,6 +620,8 @@ defmodule Module.Types.Expr do
   defp for_into(into, meta, stack, context) do
     {type, context} = of_expr(into, @expected_expr, stack, context)
 
+    # We use subtype? instead of compatible because we want to handle
+    # only binary/list, even if a dynamic with something else is given.
     if subtype?(type, @into_compile) do
       case {binary_type?(type), empty_list_type?(type)} do
         {false, true} -> {[:list], gradual?(type), context}

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

@@ -177,7 +177,7 @@ defmodule Module.Types.Pattern do
 
               case of_pattern_var(path, actual, true, info, context) do
                 {type, reachable_var?} ->
-                  # If current type is already a subtype, there is nothing to refine.
+                  # Optimization: if current type is already a subtype, there is nothing to refine.
                   with %{^version => %{type: current_type}} <- context.vars,
                        true <- subtype?(current_type, type) do
                     {var_changed?, context}

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

@@ -1231,6 +1231,16 @@ defmodule Module.Types.ExprTest do
              ) == dynamic(atom([:ok, :error, :timeout]))
     end
 
+    test "infers type for timeout" do
+      assert typecheck!(
+               [x],
+               receive do
+               after
+                 x -> x
+               end
+             ) == dynamic(union(integer(), atom([:infinity])))
+    end
+
     test "resets branches" do
       assert typecheck!(
                [x, timeout = :infinity],