Add version to case

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -437,7 +437,9 @@ defmodule Module.Types do
       # The mode to be used, see the @modes attribute
       mode: mode,
       # The function for handling local calls
-      local_handler: handler
+      local_handler: handler,
+      # Reverse arrow handling (nil | :cache | :use)
+      reverse_arrow: nil
     }
   end
 
@@ -459,7 +461,9 @@ defmodule Module.Types do
       # Local signatures used by local handler
       local_sigs: %{},
       # Track which clauses have been used across private local calls
-      local_used: %{}
+      local_used: %{},
+      # Cached reverse arrows
+      reverse_arrows: %{}
     }
   end
 

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

@@ -312,6 +312,7 @@ defmodule Module.Types.Expr do
   end
 
   def of_expr({:case, meta, [case_expr, [{:do, clauses}]]}, expected, _expr, stack, context) do
+    _ = Keyword.fetch!(meta, :version)
     {case_type, context} = of_expr(case_expr, @pending, case_expr, stack, context)
     info = {:case, meta, case_expr, case_type}
 

lib/elixir/src/elixir.hrl

@@ -31,8 +31,8 @@
   prematch=none,
   %% Stores if __STACKTRACE__ is allowed
   stacktrace=false,
-  %% A map of unused vars and a version counter for vars
-  unused={#{}, 0},
+  %% A map of unused vars
+  unused=#{},
   %% A list of modules defined in functions (runtime)
   runtime_modules=[],
   %% A tuple with maps of read and optional write current vars.
@@ -46,7 +46,9 @@
   %%     if you write foo(a = 123), the value of `a` cannot be
   %%     read in the following argument, only after the call
   %%
-  vars={#{}, false}
+  vars={#{}, false},
+  %% Stores expression version counter
+  version=0
 }).
 
 -record(elixir_erl, {

lib/elixir/src/elixir_clauses.erl

@@ -155,13 +155,14 @@ recur_cycles(Cycles, Current, Source, Seen, SkipList, Meta, Expr, E) ->
 %% Match
 
 match(Fun, Meta, Expr, AfterS, BeforeS, #{context := nil} = E) ->
-  #elixir_ex{vars=Current, unused={_, Counter} = Unused} = AfterS,
+  #elixir_ex{vars=Current, unused=Unused, version=Counter} = AfterS,
   #elixir_ex{vars={Read, _}, prematch=Prematch} = BeforeS,
 
   CallS = BeforeS#elixir_ex{
     prematch={Read, {#{}, []}, Counter},
     unused=Unused,
-    vars=Current
+    vars=Current,
+    version=Counter
   },
 
   CallE = E#{context := match},
@@ -170,15 +171,17 @@ match(Fun, Meta, Expr, AfterS, BeforeS, #{context := nil} = E) ->
   #elixir_ex{
     vars=NewCurrent,
     unused=NewUnused,
-    prematch={_, Cycles, _}
+    prematch={_, Cycles, _},
+    version=NewCounter
   } = SE,
 
   validate_cycles(Cycles, Meta, {match, Expr}, E),
 
   EndS = AfterS#elixir_ex{
     prematch=Prematch,
     unused=NewUnused,
-    vars=NewCurrent
+    vars=NewCurrent,
+    version=NewCounter
   },
 
   EndE = EE#{context := ?key(E, context)},

lib/elixir/src/elixir_def.erl

@@ -295,17 +295,17 @@ store_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults,
 %% Handling of defaults
 
 unpack_defaults(Kind, Meta, Name, Args, S, E) ->
-  {Expanded, #elixir_ex{unused={_, VersionOffset}}} = expand_defaults(Args, S, E#{context := nil}, []),
-  unpack_expanded(Kind, Meta, Name, Expanded, VersionOffset, [], []).
+  {Expanded, #elixir_ex{version=Counter}} = expand_defaults(Args, S, E#{context := nil}, []),
+  unpack_expanded(Kind, Meta, Name, Expanded, Counter, [], []).
 
-unpack_expanded(Kind, Meta, Name, [{'\\\\', DefaultMeta, [Expr, _]} | T] = List, VersionOffset, Acc, Clauses) ->
-  Base = match_defaults(Acc, length(Acc) + VersionOffset, []),
-  {Args, Invoke} = extract_defaults(List, length(Base) + VersionOffset, [], []),
+unpack_expanded(Kind, Meta, Name, [{'\\\\', DefaultMeta, [Expr, _]} | T] = List, Counter, Acc, Clauses) ->
+  Base = match_defaults(Acc, length(Acc) + Counter, []),
+  {Args, Invoke} = extract_defaults(List, length(Base) + Counter, [], []),
   Clause = {Meta, Base ++ Args, [], {super, [{super, {Kind, Name}}, {default, true} | DefaultMeta], Base ++ Invoke}},
-  unpack_expanded(Kind, Meta, Name, T, VersionOffset, [Expr | Acc], [Clause | Clauses]);
-unpack_expanded(Kind, Meta, Name, [H | T], VersionOffset, Acc, Clauses) ->
-  unpack_expanded(Kind, Meta, Name, T, VersionOffset, [H | Acc], Clauses);
-unpack_expanded(_Kind, _Meta, _Name, [], _VersionOffset, Acc, Clauses) ->
+  unpack_expanded(Kind, Meta, Name, T, Counter, [Expr | Acc], [Clause | Clauses]);
+unpack_expanded(Kind, Meta, Name, [H | T], Counter, Acc, Clauses) ->
+  unpack_expanded(Kind, Meta, Name, T, Counter, [H | Acc], Clauses);
+unpack_expanded(_Kind, _Meta, _Name, [], _Counter, Acc, Clauses) ->
   {lists:reverse(Acc), lists:reverse(Clauses)}.
 
 expand_defaults([{'\\\\', Meta, [Expr, Default]} | Args], S, E, Acc) ->

lib/elixir/src/elixir_env.erl

@@ -56,12 +56,12 @@ env_to_ex(#{context := match, versioned_vars := Vars}) ->
   #elixir_ex{
     prematch={Vars, {#{}, []}, Counter},
     vars={Vars, false},
-    unused={#{}, Counter}
+    version=Counter
   };
 env_to_ex(#{versioned_vars := Vars}) ->
   #elixir_ex{
     vars={Vars, false},
-    unused={#{}, map_size(Vars)}
+    version=map_size(Vars)
   }.
 
 %% VAR HANDLING
@@ -94,10 +94,10 @@ merge_vars(V1, V2) ->
 
 %% UNUSED VARS
 
-reset_unused_vars(#elixir_ex{unused={_Unused, Version}} = S) ->
-  S#elixir_ex{unused={#{}, Version}}.
+reset_unused_vars(#elixir_ex{} = S) ->
+  S#elixir_ex{unused=#{}}.
 
-check_unused_vars(#elixir_ex{unused={Unused, _Version}}, E) ->
+check_unused_vars(#elixir_ex{unused=Unused}, E) ->
   [elixir_errors:file_warn(calculate_span(Meta, Name), E, ?MODULE, {unused_var, Name, Overridden}) ||
     {{{Name, _Kind}, _Count}, {Meta, Overridden}} <- maps:to_list(Unused), is_unused_var(Name)],
   E.
@@ -111,10 +111,10 @@ calculate_span(Meta, Name) ->
       Meta
   end.
 
-merge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused={Unused, _Version}}, E) ->
-  #elixir_ex{unused={ClauseUnused, Version}} = S,
+merge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused=Unused}, E) ->
+  #elixir_ex{unused=ClauseUnused} = S,
   NewUnused = merge_and_check_unused_vars(Read, Unused, ClauseUnused, E),
-  S#elixir_ex{unused={NewUnused, Version}, vars={Read, Write}}.
+  S#elixir_ex{unused=NewUnused, vars={Read, Write}}.
 
 merge_and_check_unused_vars(Current, Unused, ClauseUnused, E) ->
   maps:fold(fun

lib/elixir/src/elixir_erl_var.erl

@@ -102,7 +102,7 @@ load_pair({Pair, Value}) -> {Pair, Value}.
 
 dump_binding(Binding, ErlS, ExS, PruneBefore) ->
   #elixir_erl{var_names=ErlVars} = ErlS,
-  #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
+  #elixir_ex{vars={ExVars, _}, unused=Unused} = ExS,
 
   maps:fold(fun
     ({Var, Kind} = Pair, Version, {B, V})

lib/elixir/src/elixir_expand.erl

@@ -397,8 +397,8 @@ expand({'_', Meta, Kind} = Var, S, #{context := Context} = E) when is_atom(Kind)
 expand({Name, Meta, Kind}, S, #{context := match} = E) when is_atom(Name), is_atom(Kind) ->
   #elixir_ex{
     prematch={_, _, PrematchVersion},
-    unused={Unused, Version},
-    vars={Read, Write}
+    vars={Read, Write},
+    unused=Unused
   } = S,
 
   Pair = {Name, elixir_utils:var_context(Meta, Kind)},
@@ -408,29 +408,31 @@ expand({Name, Meta, Kind}, S, #{context := match} = E) when is_atom(Name), is_at
     #{Pair := VarVersion} when VarVersion >= PrematchVersion ->
       maybe_warn_underscored_var_repeat(Meta, Name, Kind, E),
       NewUnused = var_used(Pair, Meta, VarVersion, Unused),
-      NewWrite = (Write /= false) andalso Write#{Pair => Version},
+      NewWrite = (Write /= false) andalso Write#{Pair => VarVersion},
       Var = {Name, [{version, VarVersion} | Meta], Kind},
-      {Var, S#elixir_ex{vars={Read, NewWrite}, unused={NewUnused, Version}}, E};
+      {Var, S#elixir_ex{vars={Read, NewWrite}, unused=NewUnused}, E};
 
     %% Variable is being overridden now
     #{Pair := _} ->
+      Version = S#elixir_ex.version,
       NewUnused = var_unused(Pair, Meta, Version, Unused, true),
       NewRead = Read#{Pair => Version},
       NewWrite = (Write /= false) andalso Write#{Pair => Version},
       Var = {Name, [{version, Version} | Meta], Kind},
-      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E};
+      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused=NewUnused, version=Version + 1}, E};
 
     %% Variable defined for the first time
     _ ->
+      Version = S#elixir_ex.version,
       NewUnused = var_unused(Pair, Meta, Version, Unused, false),
       NewRead = Read#{Pair => Version},
       NewWrite = (Write /= false) andalso Write#{Pair => Version},
       Var = {Name, [{version, Version} | Meta], Kind},
-      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E}
+      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused=NewUnused, version=Version + 1}, E}
   end;
 
 expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
-  #elixir_ex{vars={Read, _Write}, unused={Unused, Version}, prematch=Prematch} = S,
+  #elixir_ex{vars={Read, _Write}, unused=Unused, prematch=Prematch} = S,
   Pair = {Name, elixir_utils:var_context(Meta, Kind)},
 
   Result =
@@ -471,7 +473,7 @@ expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
     {ok, PairVersion} ->
       maybe_warn_underscored_var_access(Meta, Name, Kind, E),
       Var = {Name, [{version, PairVersion} | Meta], Kind},
-      {Var, S#elixir_ex{unused={var_used(Pair, Meta, PairVersion, Unused), Version}}, E};
+      {Var, S#elixir_ex{unused=var_used(Pair, Meta, PairVersion, Unused)}, E};
 
     Error ->
       case lists:keyfind(if_undefined, 1, Meta) of
@@ -795,8 +797,8 @@ expand_case(Meta, Expr, Opts, S, E) ->
       false -> Opts
     end,
 
-  {EOpts, SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),
-  {{'case', Meta, [EExpr, EOpts]}, SO, EO}.
+  {EOpts, #elixir_ex{version=Counter} = SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),
+  {{'case', [{version, Counter} | Meta], [EExpr, EOpts]}, SO#elixir_ex{version = Counter + 1}, EO}.
 
 rewrite_case_clauses([{do, [
   {'->', FalseMeta, [

lib/elixir/src/elixir_module.erl

@@ -494,7 +494,7 @@ maybe_prune_versioned_vars(false, _Vars, _Exs, E) ->
   E;
 maybe_prune_versioned_vars(true, Vars, ExS, E) ->
   PruneBefore = length(Vars),
-  #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
+  #elixir_ex{vars={ExVars, _}, unused=Unused} = ExS,
 
   VersionedVars =
     maps:filter(fun

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -420,7 +420,7 @@ defmodule Kernel.ExpansionTest do
                 {:=, _, [var_ver(:x, 0), 0]},
                 {:case, _, [:foo, [do: [{:->, _, [[var_ver(:x, 1)], var_ver(:x, 1)]}]]]},
                 {:=, _, [_, var_ver(:x, 0)]},
-                {:=, _, [var_ver(:x, 2), 2]}
+                {:=, _, [var_ver(:x, 3), 2]}
               ]} =
                expand_with_version(
                  quote do