WIP

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -4764,8 +4764,8 @@ defmodule Kernel do
   defp in_range(left, first, last, step) do
     quoted =
       quote do
-        :erlang.is_integer(unquote(left)) and :erlang.is_integer(unquote(first)) and
-          :erlang.is_integer(unquote(last)) and
+        unquote(generated_is_integer(left)) and unquote(generated_is_integer(first)) and
+          unquote(generated_is_integer(last)) and
           ((:erlang.>(unquote(step), 0) and
               unquote(increasing_compare(left, first, last))) or
              (:erlang.<(unquote(step), 0) and
@@ -4782,8 +4782,8 @@ defmodule Kernel do
   defp in_range_literal(left, first, last, step) when step > 0 do
     quoted =
       quote do
-        :erlang.andalso(
-          :erlang.is_integer(unquote(left)),
+        Kernel.and(
+          unquote(generated_is_integer(left)),
           unquote(increasing_compare(left, first, last))
         )
       end
@@ -4794,8 +4794,8 @@ defmodule Kernel do
   defp in_range_literal(left, first, last, step) when step < 0 do
     quoted =
       quote do
-        :erlang.andalso(
-          :erlang.is_integer(unquote(left)),
+        Kernel.and(
+          unquote(generated_is_integer(left)),
           unquote(decreasing_compare(left, first, last))
         )
       end
@@ -4809,7 +4809,7 @@ defmodule Kernel do
 
   defp in_range_step(quoted, left, first, step) do
     quote do
-      :erlang.andalso(
+      Kernel.and(
         unquote(quoted),
         :erlang."=:="(:erlang.rem(unquote(left) - unquote(first), unquote(step)), 0)
       )
@@ -4818,7 +4818,7 @@ defmodule Kernel do
 
   defp in_list(left, head, tail, expand, right, in_body?) do
     [head | tail] = :lists.map(&comp(left, &1, expand, right, in_body?), [head | tail])
-    :lists.foldl(&quote(do: :erlang.orelse(unquote(&2), unquote(&1))), head, tail)
+    :lists.foldl(&quote(do: Kernel.or(unquote(&2), unquote(&1))), head, tail)
   end
 
   defp comp(left, {:|, _, [head, tail]}, expand, right, in_body?) do
@@ -4828,15 +4828,15 @@ defmodule Kernel do
 
       [tail_head | tail] ->
         quote do
-          :erlang.orelse(
+          Kernel.or(
             :erlang."=:="(unquote(left), unquote(head)),
             unquote(in_list(left, tail_head, tail, expand, right, in_body?))
           )
         end
 
       tail when in_body? ->
         quote do
-          :erlang.orelse(
+          Kernel.or(
             :erlang."=:="(unquote(left), unquote(head)),
             :lists.member(unquote(left), unquote(tail))
           )
@@ -4851,9 +4851,13 @@ defmodule Kernel do
     quote(do: :erlang."=:="(unquote(left), unquote(right)))
   end
 
+  defp generated_is_integer(arg) do
+    quote generated: true, do: :erlang.is_integer(unquote(arg))
+  end
+
   defp increasing_compare(var, first, last) do
     quote do
-      :erlang.andalso(
+      Kernel.and(
         :erlang.>=(unquote(var), unquote(first)),
         :erlang."=<"(unquote(var), unquote(last))
       )
@@ -4862,7 +4866,7 @@ defmodule Kernel do
 
   defp decreasing_compare(var, first, last) do
     quote do
-      :erlang.andalso(
+      Kernel.and(
         :erlang."=<"(unquote(var), unquote(first)),
         :erlang.>=(unquote(var), unquote(last))
       )

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

@@ -217,7 +217,6 @@ defmodule Module.Types.Apply do
            {[non_empty_list(term()), term()], dynamic(non_empty_list(term(), term()))}
          ]},
         {:erlang, :--, [{[list(term()), list(term())], dynamic(list(term()))}]},
-        {:erlang, :andalso, [{[boolean(), term()], dynamic()}]},
         {:erlang, :delete_element, [{[integer(), open_tuple([])], dynamic(open_tuple([]))}]},
         {:erlang, :hd, [{[non_empty_list(term(), term())], dynamic()}]},
         {:erlang, :element, [{[integer(), open_tuple([])], dynamic()}]},
@@ -226,7 +225,6 @@ defmodule Module.Types.Apply do
         {:erlang, :list_to_tuple, [{[list(term())], dynamic(open_tuple([]))}]},
         {:erlang, :max, [{[term(), term()], dynamic()}]},
         {:erlang, :min, [{[term(), term()], dynamic()}]},
-        {:erlang, :orelse, [{[boolean(), term()], dynamic()}]},
         {:erlang, :send, [{[send_destination, term()], dynamic()}]},
         {:erlang, :setelement, [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
         {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
@@ -263,9 +261,7 @@ defmodule Module.Types.Apply do
       ] do
     [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
 
-    true =
-      Code.ensure_loaded?(mod) and
-        (function_exported?(mod, fun, arity) or fun in [:orelse, :andalso])
+    true = Code.ensure_loaded?(mod)
 
     domain_clauses =
       case clauses do

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

@@ -312,10 +312,17 @@ defmodule Module.Types.Expr do
     {case_type, context} = of_expr(case_expr, @pending, case_expr, stack, context)
     info = {:case, meta, case_type, case_expr}
 
-    # If we are only type checking the expression and the expression is a literal,
-    # let's mark it as generated, as it is most likely a macro code. However, if
-    # no clause is matched, we should still check for that.
-    if Macro.quoted_literal?(case_expr) do
+    added_meta =
+      if Macro.quoted_literal?(case_expr) do
+        [generated: true]
+      else
+        case_expr |> get_meta() |> Keyword.take([:generated])
+      end
+
+    # If the expression is generated or the construct is a literal,
+    # it is most likely a macro code. However, if no clause is matched,
+    # we should still check for that.
+    if added_meta != [] do
       for {:->, meta, args} <- clauses, do: {:->, [generated: true] ++ meta, args}
     else
       clauses

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

@@ -760,6 +760,7 @@ defmodule Module.Types.Pattern do
   #    the environment vars.
 
   @atom_true atom([true])
+  @atom_false atom([false])
 
   defp of_guards([], _stack, context) do
     context
@@ -885,16 +886,28 @@ defmodule Module.Types.Pattern do
     end
   end
 
-  # TODO: Move orelse and andalso handling here, both may never be executed
-  defp of_remote(fun, meta, [left, right], call, expected, stack, context)
-       when fun in [:or, :orelse] do
-    {info, [left_domain, right_domain], context} =
-      Apply.remote_domain(:erlang, fun, [left, right], expected, meta, stack, context)
+  defp of_remote(fun, _meta, [left, right], call, expected, stack, context)
+       when fun in [:andalso, :orelse] do
+    {both_domain, abort_domain} =
+      case fun do
+        :andalso -> {@atom_true, @atom_false}
+        :orelse -> {@atom_false, @atom_true}
+      end
+
+    # For example, if the expected type is true for andalso, then it can
+    # only be true if both clauses are executed, so we know the first
+    # argument has to be true and the second has to be expected.
+    {left_domain, right_domain, surely_rhs?} =
+      if subtype?(expected, both_domain) do
+        {both_domain, expected, true}
+      else
+        {boolean(), term(), false}
+      end
 
     {left_type, context} = of_guard(left, left_domain, call, stack, context)
 
     {right_type, context} =
-      if fun == :or do
+      if surely_rhs? do
         of_guard(right, right_domain, call, stack, context)
       else
         %{pattern_info: pattern_info} = context
@@ -903,8 +916,11 @@ defmodule Module.Types.Pattern do
         {type, %{context | pattern_info: pattern_info}}
       end
 
-    args_types = [left_type, right_type]
-    Apply.remote_apply(info, :erlang, fun, args_types, call, stack, context)
+    if compatible?(left_type, abort_domain) do
+      {union(abort_domain, right_type), context}
+    else
+      {right_type, context}
+    end
   end
 
   defp of_remote(fun, meta, args, call, expected, stack, context) do

lib/elixir/lib/range.ex

@@ -207,12 +207,6 @@ defmodule Range do
     %Range{first: first, last: last, step: step}
   end
 
-  def new(first, last) do
-    raise ArgumentError,
-          "ranges (first..last) expect both sides to be integers, " <>
-            "got: #{inspect(first)}..#{inspect(last)}"
-  end
-
   @doc """
   Creates a new range with `step`.
 

lib/elixir/test/elixir/enum_test.exs

@@ -302,10 +302,6 @@ defmodule EnumTest do
     assert Enum.drop([1, 2, 3], -2) == [1]
     assert Enum.drop([1, 2, 3], -4) == []
     assert Enum.drop([], 3) == []
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.drop([1, 2, 3], 0.0)
-    end
   end
 
   test "drop/2 with streams" do
@@ -542,10 +538,6 @@ defmodule EnumTest do
       Enum.map_every([1, 2, 3], -1, fn x -> x * 2 end)
     end
 
-    assert_raise FunctionClauseError, fn ->
-      Enum.map_every(1..10, 3.33, fn x -> x * 2 end)
-    end
-
     assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 9, fn x -> x + 1000 end) ==
              [1001, 2, 3, 4, 5, 6, 7, 8, 9, 1010]
 
@@ -1204,10 +1196,6 @@ defmodule EnumTest do
     assert_raise FunctionClauseError, fn ->
       Enum.slice(list, 0.99, 0)
     end
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.slice(list, 0, 0.99)
-    end
   end
 
   test "slice on infinite streams" do
@@ -1432,10 +1420,6 @@ defmodule EnumTest do
     assert Enum.split([1, 2, 3], -2) == {[1], [2, 3]}
     assert Enum.split([1, 2, 3], -3) == {[], [1, 2, 3]}
     assert Enum.split([1, 2, 3], -10) == {[], [1, 2, 3]}
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.split([1, 2, 3], 0.0)
-    end
   end
 
   test "split_while/2" do
@@ -1537,10 +1521,6 @@ defmodule EnumTest do
     assert Enum.take([1, 2, 3], -2) == [2, 3]
     assert Enum.take([1, 2, 3], -4) == [1, 2, 3]
     assert Enum.take([], 3) == []
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.take([1, 2, 3], 0.0)
-    end
   end
 
   test "take_every/2" do
@@ -1554,10 +1534,6 @@ defmodule EnumTest do
     assert_raise FunctionClauseError, fn ->
       Enum.take_every([1, 2, 3], -1)
     end
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.take_every(1..10, 3.33)
-    end
   end
 
   test "take_random/2" do
@@ -1597,14 +1573,6 @@ defmodule EnumTest do
     assert_raise FunctionClauseError, fn ->
       Enum.take_random(1..10, -1)
     end
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.take_random(1..10, 10.0)
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.take_random(1..10, 128.1)
-    end
   end
 
   test "take_while/2" do
@@ -2406,14 +2374,6 @@ defmodule EnumTest.Range do
       Enum.slice(1..5, 0, -1)
     end
 
-    assert_raise FunctionClauseError, fn ->
-      Enum.slice(1..5, 0.99, 0)
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      Enum.slice(1..5, 0, 0.99)
-    end
-
     assert Enum.slice(5..1//-1, 0, 0) == []
     assert Enum.slice(5..1//-1, 0, 1) == [5]
     assert Enum.slice(5..1//-1, 0, 2) == [5, 4]

lib/elixir/test/elixir/kernel_test.exs

@@ -658,7 +658,7 @@ defmodule KernelTest do
     end
 
     test "inside and/2" do
-      response = %{code: 200}
+      response = Process.get(:unused, %{code: 200})
 
       if is_map(response) and response.code in 200..299 do
         :pass
@@ -712,20 +712,13 @@ defmodule KernelTest do
       """)
     end
 
-    test "with a non-integer range" do
-      message = "ranges (first..last) expect both sides to be integers, got: 0..5.0"
-
-      assert_raise ArgumentError, message, fn ->
-        last = 5.0
-        1 in 0..last
-      end
-    end
-
     test "hoists variables and keeps order" do
       # Ranges
       result = expand_to_string(quote(do: rand() in 1..2))
       assert result =~ "var = rand()"
 
+      result = expand_to_string(quote(do: var in 1..2), :guard)
+
       assert result =~ """
              :erlang.andalso(
                :erlang.is_integer(var),
@@ -740,6 +733,8 @@ defmodule KernelTest do
       # Lists
       result = expand_to_string(quote(do: rand() in [1, 2]))
       assert result =~ "var = rand()"
+
+      result = expand_to_string(quote(do: var in [1, 2]), :guard)
       assert result =~ ":erlang.orelse(:erlang.\"=:=\"(var, 1), :erlang.\"=:=\"(var, 2))"
 
       result = expand_to_string(quote(do: rand() in [1 | [2]]))
@@ -750,34 +745,34 @@ defmodule KernelTest do
     end
 
     test "is optimized" do
-      assert expand_to_string(quote(do: foo in [])) ==
-               "_ = foo\nfalse"
+      assert expand_to_string(quote(do: foo in []), :guard) ==
+               "false"
 
-      assert expand_to_string(quote(do: foo in [1, 2, 3])) == """
+      assert expand_to_string(quote(do: foo in [1, 2, 3]), :guard) == """
              :erlang.orelse(
                :erlang.orelse(:erlang.\"=:=\"(foo, 1), :erlang.\"=:=\"(foo, 2)),
                :erlang.\"=:=\"(foo, 3)
              )\
              """
 
-      assert expand_to_string(quote(do: foo in 0..1)) == """
+      assert expand_to_string(quote(do: foo in 0..1), :guard) == """
              :erlang.andalso(
                :erlang.is_integer(foo),
                :erlang.andalso(:erlang.>=(foo, 0), :erlang.\"=<\"(foo, 1))
              )\
              """
 
-      assert expand_to_string(quote(do: foo in -1..0)) == """
+      assert expand_to_string(quote(do: foo in -1..0), :guard) == """
              :erlang.andalso(
                :erlang.is_integer(foo),
                :erlang.andalso(:erlang.>=(foo, -1), :erlang.\"=<\"(foo, 0))
              )\
              """
 
-      assert expand_to_string(quote(do: foo in 1..1)) ==
+      assert expand_to_string(quote(do: foo in 1..1), :guard) ==
                ":erlang.\"=:=\"(foo, 1)"
 
-      assert expand_to_string(quote(do: 2 in 1..3)) ==
+      assert expand_to_string(quote(do: 2 in 1..3), :guard) ==
                ":erlang.andalso(:erlang.is_integer(2), :erlang.andalso(:erlang.>=(2, 1), :erlang.\"=<\"(2, 3)))"
     end