Deprecate x in y inside matches

Author: José Valim

lib/elixir/lib/file.ex

@@ -481,7 +481,7 @@ defmodule File do
         case F.list_dir(src) do
           { :ok, files } ->
             case mkdir(dest) do
-              success in [:ok, { :error, :eexist }] ->
+              success when success in [:ok, { :error, :eexist }] ->
                 Enum.reduce(files, [dest|acc], fn(x, acc) ->
                   do_cp_r(FN.join(src, x), FN.join(dest, x), callback, acc)
                 end)

lib/elixir/lib/kernel.ex

@@ -2636,8 +2636,8 @@ defmodule Kernel do
 
     quote do
       case unquote(condition) do
-        _ in [false, nil] -> unquote(else_clause)
-        _                 -> unquote(do_clause)
+        unquote(cond_var) when unquote(cond_var) in [false, nil] -> unquote(else_clause)
+        _ -> unquote(do_clause)
       end
     end
   end
@@ -2987,8 +2987,8 @@ defmodule Kernel do
   defmacro left && right do
     quote do
       case unquote(left) do
-        var!(andand, false) in [false, nil] ->
-          var!(andand, false)
+        unquote(temp_var) when unquote(temp_var) in [false, nil] ->
+          unquote(temp_var)
         _ ->
           unquote(right)
       end
@@ -3018,10 +3018,10 @@ defmodule Kernel do
   defmacro left || right do
     quote do
       case unquote(left) do
-        var!(oror, false) in [false, nil] ->
+        unquote(temp_var) when unquote(temp_var) in [false, nil] ->
           unquote(right)
-        var!(oror, false) ->
-          var!(oror, false)
+        unquote(temp_var) ->
+          unquote(temp_var)
       end
     end
   end
@@ -3619,13 +3619,26 @@ defmodule Kernel do
   defp expand_compact([]),                      do: []
 
   defp falsy_clause(meta, acc) do
-    { [quote(do: _ in [false, nil])], meta, acc }
+    { [quote(do: unquote(cond_var) when unquote(cond_var) in [false, nil])], meta, acc }
   end
 
   defp truthy_clause(meta, clause) do
     { [quote(do: _)], meta, clause }
   end
 
+  # Setting cond: true in metadata turns on a small optimization
+  # in Elixir compiler. In the long run, we want to bring this
+  # optimization to Elixir land, but not right now.
+  defp cond_var do
+    { :x, [cond: true, temp: true], Kernel }
+  end
+
+  # A temporary var only lasts its current clause, never leak
+  # into other clauses.
+  defp temp_var do
+    { :x, [temp: true], Kernel }
+  end
+
   defp get_line(meta) do
     case :lists.keyfind(:line, 1, meta) do
       { :line, line } -> line

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -48,7 +48,7 @@ defmodule Kernel.ParallelCompiler do
     result = spawn_compilers(files, files, path, callbacks, [], [], schedulers, [])
 
     # In case --warning-as-errors is enabled and there was a warning,
-    # compilation status will be set to error and we fail with Kernel.CompilationError
+    # compilation status will be set to error and we fail with CompileError
     case :elixir_code_server.call(:compilation_status) do
       :ok    -> result
       :error -> raise CompileError, [], []

lib/elixir/lib/kernel/special_forms.ex

@@ -855,10 +855,6 @@ defmodule Kernel.SpecialForms do
 
   @doc """
   Defines a variable in the given context.
-
-  If the context is `false`, it is not stored in any particular
-  context and the variable is not shared in between clauses.
-
   Check `quote/2` for more information.
   """
   defmacro var!(var, context)

lib/elixir/src/elixir_macros.erl

@@ -44,6 +44,7 @@ translate({ in, Meta, [Left, Right] }, #elixir_scope{extra_guards=nil} = S) ->
   { TExpr, TS };
 
 translate({ in, Meta, [Left, Right] }, #elixir_scope{extra_guards=Extra} = S) ->
+  elixir_errors:deprecation(Meta, S#elixir_scope.file, "in operator inside matches is deprecated, please move it to a guard"),
   { TVar, TExpr, TS } = translate_in(Meta, Left, Right, S),
   { TVar, TS#elixir_scope{extra_guards=[TExpr|Extra]} };
 
@@ -281,8 +282,18 @@ decreasing_compare(Line, Var, Start, End) ->
     { op, Line, '=<', Var, Start },
     { op, Line, '>=', Var, End } }.
 
-rewrite_case_clauses([{do,Meta1,[{in,_,[{'_',_,_},[false,nil]]}],False},{do,Meta2,[{'_',_,_}],True}]) ->
-  [{do,Meta1,[false],False},{do,Meta2,[true],True}];
+%% TODO: Once we have elixir_exp, we can move this
+%% clause to Elixir code and out of case.
+rewrite_case_clauses([
+    {do,Meta1,[{'when',_,[{V,M,C},{in,_,[{V,M,C},[false,nil]]}]}],False},
+    {do,Meta2,[{'_',_,UC}],True}] = Clauses)
+    when is_atom(V), is_list(M), is_atom(C), is_atom(UC) ->
+  case lists:keyfind('cond', 1, M) of
+    { 'cond', true } ->
+      [{do,Meta1,[false],False},{do,Meta2,[true],True}];
+    _ ->
+      Clauses
+  end;
 
 rewrite_case_clauses(Clauses) ->
   Clauses.

lib/elixir/src/elixir_scope.erl

@@ -13,6 +13,7 @@
 translate_var(Meta, Name, Kind, S, Callback) when is_atom(Kind); is_integer(Kind) ->
   Line = ?line(Meta),
   Vars = S#elixir_scope.vars,
+  Temp = lists:keyfind(temp, 1, Meta) == { temp, true },
   Tuple = { Name, Kind },
 
   case Name of
@@ -41,7 +42,7 @@ translate_var(Meta, Name, Kind, S, Callback) when is_atom(Kind); is_integer(Kind
                   true -> ordsets:add_element(Tuple, TempVars)
                 end,
                 clause_vars=if
-                  ClauseVars == nil; Kind == false -> ClauseVars;
+                  ClauseVars == nil; Temp == true -> ClauseVars;
                   true -> orddict:store(Tuple, RealName, ClauseVars)
                 end
               } }

lib/elixir/test/elixir/kernel/case_test.exs

@@ -30,33 +30,13 @@ defmodule Kernel.CaseTest do
     end) == :done
   end
 
-  test :match_with_in do
-    assert(case 3 do
-      x in [1, 2, 3] ->
-        true
-    end)
-
-    assert(case { 3, 3 } do
-      { x in [1, 2, 3], y } when y == 2 ->
-        false
-      { x in [1, 2, 3], y } when y == 1 when y == 3 ->
-        true
-    end)
-  end
-
   test :in_operator_outside_case do
     x = 1
     y = 4
     assert x in [1, 2, 3], "in assertion"
     assert not y in [1, 2, 3], "not in assertion"
   end
 
-  test :in_operator_in_function_definition do
-    assert with_in(3, :it_works)  == :it_works
-    assert with_in(3, "it fails") == false
-    assert with_in(0, :it_fails)  == false
-  end
-
   defp get_case do
     case internal do
       :invalid ->
@@ -93,7 +73,4 @@ defmodule Kernel.CaseTest do
     end
     {x, vx}
   end
-
-  defp with_in(x in [1, 2, 3], other) when is_atom(other), do: other
-  defp with_in(_, _), do: false
 end

lib/elixir/test/elixir/kernel/def_clauses_test.exs

@@ -23,15 +23,6 @@ defmodule Kernel.ClausesTest do
   def bar, do: 1
   defclause foo(1), do: 2
 
-  test :in_operator_in_function_definition do
-    assert with_in(3, :it_works)  == :it_works
-    assert with_in(3, "it fails") == false
-    assert with_in(0, :it_fails)  == false
-  end
-
-  defp with_in(x in [1, 2, 3], other) when is_atom(other), do: other
-  defp with_in(_, _), do: false
-
   test :clauses_without_implementation_can_have_default_args do
     assert a_number == 13
     assert a_number(4) == 17

lib/elixir/test/elixir/kernel/warning_test.exs

@@ -180,22 +180,8 @@ defmodule Kernel.WarningTest do
       end
       """
     end) =~ "nofile:6: this clause cannot match because a previous clause at line 5 always matches"
-
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample3 do
-        def is_binary_cond_case do
-          v = "bc"
-          case(is_binary(v)) do
-            _ in [false, nil] -> :ok
-            _ -> :bin
-          end
-        end
-      end
-      """
-    end) =~ "nofile:5: this clause cannot match because a previous clause at line 6 always matches"
   after
-    purge [Sample1, Sample2, Sample3]
+    purge [Sample1, Sample2]
   end
 
   test :unused_docs do

lib/elixir/test/elixir/macro_test.exs

@@ -157,19 +157,21 @@ defmodule MacroTest do
   end
 
   test :expand_once_with_imported_macro do
+    temp_var = { :x, [temp: true], Kernel }
     assert Macro.expand_once(quote(do: 1 || false), __ENV__) == (quote context: Kernel do
       case 1 do
-        var!(oror, false) in [false, nil] -> false
-        var!(oror, false) -> var!(oror, false)
+        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
+        unquote(temp_var) -> unquote(temp_var)
       end
     end)
   end
 
   test :expand_once_with_require_macro do
+    temp_var = { :x, [temp: true], Kernel }
     assert Macro.expand_once(quote(do: Kernel.||(1, false)), __ENV__) == (quote context: Kernel do
       case 1 do
-        var!(oror, false) in [false, nil] -> false
-        var!(oror, false) -> var!(oror, false)
+        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
+        unquote(temp_var) -> unquote(temp_var)
       end
     end)
   end
@@ -187,10 +189,11 @@ defmodule MacroTest do
   end
 
   test :expand do
+    temp_var = { :x, [temp: true], Kernel }
     assert Macro.expand(quote(do: oror(1, false)), __ENV__) == (quote context: Kernel do
       case 1 do
-        var!(oror, false) in [false, nil] -> false
-        var!(oror, false) -> var!(oror, false)
+        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
+        unquote(temp_var) -> unquote(temp_var)
       end
     end)
   end