Keep Kernel.in/2 as :lists.member/2 and optimize in type checker and Erlang pass

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -4707,9 +4707,9 @@ defmodule Kernel do
       [head | tail] = list ->
         # We only expand lists in the body if they are relatively
         # short and it is made only of literal expressions.
-        case not in_body? or small_literal_list?(right) do
-          true -> in_var(in_body?, left, &in_list(&1, head, tail, expand, list, in_body?))
-          false -> quote(do: :lists.member(unquote(left), unquote(right)))
+        case in_body? do
+          false -> in_list(left, head, tail, expand, list, in_body?)
+          true -> quote(do: :lists.member(unquote(left), unquote(right)))
         end
 
       %{} = right ->
@@ -4756,12 +4756,6 @@ defmodule Kernel do
     end
   end
 
-  defp small_literal_list?(list) when is_list(list) and length(list) <= 32 do
-    :lists.all(fn x -> is_binary(x) or is_atom(x) or is_number(x) end, list)
-  end
-
-  defp small_literal_list?(_list), do: false
-
   defp in_range(left, first, last, step) when is_integer(step) do
     in_range_literal(left, first, last, step)
   end

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

@@ -236,6 +236,9 @@ defmodule Module.Types.Apply do
         {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
         {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]},
 
+        ## Lists
+        {:lists, :member, [{[term(), list(term())], boolean()}]},
+
         ## Map
         {Map, :from_struct, [{[open_map()], open_map(__struct__: not_set())}]},
         {Map, :get, [{[open_map(), term()], term()}]},
@@ -367,8 +370,8 @@ defmodule Module.Types.Apply do
     right_literal? = Macro.quoted_literal?(right)
 
     case {left_literal?, right_literal?} do
-      {true, false} -> literal_compare(name, right, left, expected, expr, stack, context, of_fun)
-      {false, true} -> literal_compare(name, left, right, expected, expr, stack, context, of_fun)
+      {true, false} -> custom_compare(name, right, left, expected, expr, stack, context, of_fun)
+      {false, true} -> custom_compare(name, left, right, expected, expr, stack, context, of_fun)
       {literal?, _} -> compare(name, left, right, literal?, expr, stack, context, of_fun)
     end
   end
@@ -479,6 +482,54 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp do_remote(:lists, :member, [arg, list] = args, expected, expr, stack, context, of_fun)
+       when is_list(list) and list != [] do
+    case booleaness(expected) do
+      {polarity, _maybe_or_always} ->
+        {return, acc} =
+          case polarity do
+            true -> {@atom_true, none()}
+            false -> {@atom_false, term()}
+          end
+
+        {expected, singleton?, context} =
+          Enum.reduce(list, {acc, true, context}, fn literal, {acc, all_singleton?, context} ->
+            {type, context} = of_fun.(literal, term(), expr, stack, context)
+
+            if singleton?(type) do
+              acc = if polarity, do: union(acc, type), else: intersection(acc, negation(type))
+              {acc, all_singleton?, context}
+            else
+              acc = if polarity, do: union(acc, type), else: acc
+              {acc, false, context}
+            end
+          end)
+
+        {arg_type, context} = of_fun.(arg, expected, expr, stack, context)
+
+        cond do
+          # Return a precise result
+          singleton? and subtype?(arg_type, expected) ->
+            {return(return, [arg_type, expected], stack), context}
+
+          # Singleton types with reverse polarity are negated, so we don't check for disjoint
+          (singleton? and not polarity) or not is_warning(stack) ->
+            {return(boolean(), [arg_type, expected], stack), context}
+
+          # Nothing in common between left and right, emit a warning
+          disjoint?(arg_type, expected) ->
+            error = {:mismatched_comparison, arg_type, list(expected)}
+            remote_error(error, :lists, :member, 2, expr, stack, context)
+
+          true ->
+            {return(boolean(), [arg_type, expected], stack), context}
+        end
+
+      _ ->
+        remote_domain(:lists, :member, args, expected, elem(expr, 1), stack, context)
+    end
+  end
+
   defp do_remote(mod, fun, args, expected, expr, stack, context, _of_fun) do
     remote_domain(mod, fun, args, expected, elem(expr, 1), stack, context)
   end
@@ -495,7 +546,7 @@ defmodule Module.Types.Apply do
             when (fun in [:length, :map_size] and is_integer(literal) and literal >= 0) or
                    (fun in [:tuple_size] and literal in 0..15)
 
-  defp literal_compare(
+  defp custom_compare(
          name,
          {{:., _, [:erlang, fun]}, _, [arg]} = left,
          literal,
@@ -547,18 +598,14 @@ defmodule Module.Types.Apply do
     end
   end
 
-  defp literal_compare(name, arg, literal, expected, expr, stack, context, of_fun) do
-    {type, context} = of_fun.(literal, term(), expr, stack, context)
-    literal_compare(name, arg, type, singleton?(type), expected, expr, stack, context, of_fun)
-  end
-
-  def literal_compare(name, arg, type, singleton?, expected, expr, stack, context, of_fun) do
+  defp custom_compare(name, arg, literal, expected, expr, stack, context, of_fun) do
     case booleaness(expected) do
       booleaness when booleaness in [:maybe_both, :none] ->
-        {arg_type, context} = of_fun.(arg, term(), expr, stack, context)
-        return_compare(name, arg_type, type, boolean(), false, expr, stack, context)
+        compare(name, arg, literal, false, expr, stack, context, of_fun)
 
       {boolean, _maybe_or_always} ->
+        {type, context} = of_fun.(literal, term(), expr, stack, context)
+
         {polarity, return} =
           case boolean do
             true -> {name in [:==, :"=:="], @atom_true}
@@ -567,7 +614,7 @@ defmodule Module.Types.Apply do
 
         # This logic mirrors the code in `Pattern.of_pattern_tree`
         # If it is a singleton, we can always be precise
-        if singleton? do
+        if singleton?(type) do
           expected = if polarity, do: type, else: negation(type)
           {arg_type, context} = of_fun.(arg, expected, expr, stack, context)
           result = if subtype?(arg_type, expected), do: return, else: boolean()
@@ -1849,7 +1896,7 @@ defmodule Module.Types.Apply do
   end
 
   def format_diagnostic({{:mismatched_comparison, left, right}, mfac, expr, context}) do
-    {_, name, _, _} = mfac
+    {mod, name, _, _} = mfac
     traces = collect_traces(expr, context)
 
     %{
@@ -1863,7 +1910,7 @@ defmodule Module.Types.Apply do
 
           given types:
 
-              #{type_comparison_to_string(name, left, right) |> indent(4)}
+              #{type_comparison_to_string(mod, name, left, right) |> indent(4)}
           """,
           format_traces(traces),
           """
@@ -1877,7 +1924,7 @@ defmodule Module.Types.Apply do
   end
 
   def format_diagnostic({{:struct_comparison, left, right}, mfac, expr, context}) do
-    {_, name, _, _} = mfac
+    {mod, name, _, _} = mfac
     traces = collect_traces(expr, context)
 
     %{
@@ -1891,7 +1938,7 @@ defmodule Module.Types.Apply do
 
           given types:
 
-              #{type_comparison_to_string(name, left, right) |> indent(4)}
+              #{type_comparison_to_string(mod, name, left, right) |> indent(4)}
           """,
           format_traces(traces),
           """
@@ -1989,8 +2036,8 @@ defmodule Module.Types.Apply do
 
   alias Inspect.Algebra, as: IA
 
-  defp type_comparison_to_string(fun, left, right) do
-    {_, fun, _, _} = :elixir_rewrite.erl_to_ex(:erlang, fun, [left, right])
+  defp type_comparison_to_string(mod, fun, left, right) do
+    {_, fun, _, _} = :elixir_rewrite.erl_to_ex(mod, fun, [left, right])
 
     {fun, [], [to_quoted(left, collapse_structs: true), to_quoted(right, collapse_structs: true)]}
     |> Code.Formatter.to_algebra()

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

@@ -1046,24 +1046,10 @@ defmodule Module.Types.Pattern do
     of_remote(fun, args, call, expected, stack, context)
   end
 
-  # This is reconstructed as part of orelse
-  def of_guard({{:., _, [Kernel, :in]}, _meta, [left, right]} = call, expected, _, stack, context) do
-    {right, context} = Enum.map_reduce(right, context, &of_guard(&1, term(), call, stack, &2))
-    {singleton, non_singleton} = Enum.split_with(right, &singleton?/1)
-
-    fun = fn
-      [], _singleton?, context ->
-        {none(), context}
-
-      types, singleton?, context ->
-        type = Enum.reduce(types, &union/2)
-        fun = &of_guard/5
-        Apply.literal_compare(:"=:=", left, type, singleton?, expected, call, stack, context, fun)
-    end
-
-    {singleton_type, context} = fun.(singleton, true, context)
-    {non_singleton_type, context} = fun.(non_singleton, false, context)
-    {union(singleton_type, non_singleton_type), context}
+  # The only possible case right now is the rewritten :lists.member/2 checks
+  def of_guard({{:., _, [mod, fun]}, _meta, args} = call, expected, _, stack, context)
+      when is_atom(mod) and is_atom(fun) do
+    Apply.remote(mod, fun, args, expected, call, stack, context, &of_guard/5)
   end
 
   # var
@@ -1158,7 +1144,7 @@ defmodule Module.Types.Pattern do
     # building nested conditional environments.
     [left | right] =
       case unpack_op(call, fun, []) do
-        entries when fun == :orelse -> reconstruct_kernel_in(entries)
+        entries when fun == :orelse -> reconstruct_lists_member(entries)
         entries -> entries
       end
 
@@ -1216,24 +1202,27 @@ defmodule Module.Types.Pattern do
     [other | acc]
   end
 
-  defp reconstruct_kernel_in([head | tail]) do
+  # Reconstruct left in right operations but only when the right-side is a literal.
+  # When the right-side is not a literal, we need to track dependencies between
+  # left and right-side, which is currently not done for the `:lists.member/2` handling.
+  defp reconstruct_lists_member([head | tail]) do
     with {{:., dot_meta, [:erlang, :"=:="]}, meta, [left, right]} <- head,
          true <- Macro.quoted_literal?(right),
          false <- data_size_op?(left),
-         {[_ | _] = entries, tail} <- reconstruct_kernel_in(tail, left, []) do
+         {[_ | _] = entries, tail} <- reconstruct_lists_member(tail, left, []) do
       in_args = [left, [right | entries]]
-      [{{:., dot_meta, [Kernel, :in]}, meta, in_args} | reconstruct_kernel_in(tail)]
+      [{{:., dot_meta, [:lists, :member]}, meta, in_args} | reconstruct_lists_member(tail)]
     else
-      _ -> [head | reconstruct_kernel_in(tail)]
+      _ -> [head | reconstruct_lists_member(tail)]
     end
   end
 
-  defp reconstruct_kernel_in([]), do: []
+  defp reconstruct_lists_member([]), do: []
 
-  defp reconstruct_kernel_in(list, left, acc) do
+  defp reconstruct_lists_member(list, left, acc) do
     with [{{:., _, [:erlang, :"=:="]}, _, [^left, right]} | tail] <- list,
          true <- Macro.quoted_literal?(right) do
-      reconstruct_kernel_in(tail, left, [right | acc])
+      reconstruct_lists_member(tail, left, [right | acc])
     else
       _ -> {Enum.reverse(acc), list}
     end

lib/elixir/src/elixir_erl_pass.erl

@@ -589,6 +589,44 @@ translate_remote(maps, put, Meta, [Key, Value, Map], S) ->
     {[TKey, TValue, TMap], TS} ->
       {{map, Ann, TMap, [{map_field_assoc, Ann, TKey, TValue}]}, TS}
   end;
+translate_remote(lists, member, Meta, [Expr, [Head | Tail] = List], S) ->
+  Ann = ?ann(Meta),
+
+  case optimize_list_membership(List, 0) of
+    true ->
+      {TExpr, S1} = translate(Expr, Ann, S),
+
+      {TVar, TFun, S3} =
+        case TExpr of
+          {var, _, _} ->
+            {TExpr, fun(Orelse) -> Orelse end, S1};
+
+          _ ->
+            {VarName, S2} = elixir_erl_var:build('_', S1),
+            Generated = erl_anno:set_generated(true, Ann),
+            Var = {var, Generated, VarName},
+            Fun = fun(Orelse) -> {block, Generated, [{match, Generated, Var, TExpr}, Orelse]} end,
+            {Var, Fun, S2}
+        end,
+
+      {THead, _} = translate(Head, Ann, S),
+
+      TOrelse =
+        lists:foldl(
+          fun(X, Acc) ->
+            {TX, _} = translate(X, Ann, S),
+            {op, Ann, 'orelse', Acc, {op, Ann, '=:=', TVar, TX}}
+          end,
+          {op, Ann, '=:=', TVar, THead},
+          Tail
+        ),
+
+      {TFun(TOrelse), S3};
+
+    false ->
+      {TArgs, SA} = translate_args([Expr, List], Ann, S),
+      {{call, Ann, {remote, Ann, {atom, Ann, lists}, {atom, Ann, member}}, TArgs}, SA}
+  end;
 translate_remote(maps, merge, Meta, [Map1, Map2], S) ->
   Ann = ?ann(Meta),
 
@@ -632,6 +670,14 @@ translate_remote(Left, Right, Meta, Args, S) ->
       {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA}
   end.
 
+optimize_list_membership([Head | Tail], Count)
+    when Count =< 32, is_number(Head) orelse is_atom(Head) orelse is_binary(Head) ->
+  optimize_list_membership(Tail, Count + 1);
+optimize_list_membership([], _Count) ->
+  true;
+optimize_list_membership(_, _Count) ->
+  false.
+
 rewrite_strategy(erlang, Right, Args) ->
   Arity  = length(Args),
   case elixir_utils:guard_op(Right, Arity) of

lib/elixir/src/elixir_rewrite.erl

@@ -109,6 +109,7 @@ inline(Mod, Fun, Arity) -> inner_inline(ex_to_erl, Mod, Fun, Arity).
 ?inline(?kernel, floor, 1, erlang, floor);
 ?inline(?kernel, 'function_exported?', 3, erlang, function_exported);
 ?inline(?kernel, hd, 1, erlang, hd);
+?inline(?kernel, in, 2, lists, member);
 ?inline(?kernel, is_atom, 1, erlang, is_atom);
 ?inline(?kernel, is_binary, 1, erlang, is_binary);
 ?inline(?kernel, is_bitstring, 1, erlang, is_bitstring);

lib/elixir/test/elixir/kernel_test.exs

@@ -696,16 +696,7 @@ 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]]))
-      assert result =~ ":lists.member(rand(), [1 | [2]]"
-
-      result = expand_to_string(quote(do: rand() in [1 | some_call()]))
-      assert result =~ ":lists.member(rand(), [1 | some_call()]"
+      assert result =~ ":lists.member(rand(), [1, 2]"
     end
 
     test "is optimized" do

lib/elixir/test/elixir/macro_test.exs

@@ -596,15 +596,17 @@ defmodule MacroTest do
     end
 
     test "left-associative operators" do
-      {result, formatted} = dbg_format(List.first([]) || "yes" || raise("foo"))
+      {result, formatted} =
+        dbg_format(List.first([]) || Process.get(:unknown, "yes") || raise("foo"))
+
       assert result == "yes"
 
       assert formatted =~ "macro_test.exs"
 
       assert formatted =~ """
              List.first([]) #=> nil
-             List.first([]) || "yes" #=> "yes"
-             List.first([]) || "yes" || raise "foo" #=> "yes"
+             List.first([]) || Process.get(:unknown, "yes") #=> "yes"
+             List.first([]) || Process.get(:unknown, "yes") || raise "foo" #=> "yes"
              """
     end