Fix shadowing warning in case with function, closes #1524

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -10,6 +10,7 @@
 
 -record(elixir_scope, {
   context=nil,             %% can be assign, guards or nil
+  extra=nil,               %% extra information about the context, like fn_match for fns
   noname=false,            %% when true, don't add new names (used by try)
   super=false,             %% when true, it means super was invoked
   caller=false,            %% when true, it means caller was invoked

lib/elixir/src/elixir_errors.erl

@@ -141,16 +141,15 @@ handle_file_warning(_, File, {Line,erl_lint,{undefined_behaviour,Module}}) ->
 handle_file_warning(_, _File, {Line,erl_lint,{unused_var,_Var}}) when Line =< 0 ->
   [];
 
+%% Ignore shadowed vars as we guarantee no conflicts ourselves
+handle_file_warning(_, _File, {_Line,erl_lint,{shadowed_var,_Var,_Where}}) ->
+  [];
+
 %% Properly format other unused vars
 handle_file_warning(_, File, {Line,erl_lint,{unused_var,Var}}) ->
   Message = format_error(erl_lint, { unused_var, format_var(Var) }),
   warn(file_format(Line, File, Message));
 
-%% Properly format shadowed vars
-handle_file_warning(_, File, {Line,erl_lint,{shadowed_var,Var,Where}}) ->
-  Message = format_error(erl_lint, { shadowed_var, format_var(Var), Where }),
-  warn(file_format(Line, File, Message));
-
 %% Default behavior
 handle_file_warning(_, File, {Line,Module,Desc}) ->
   Message = format_error(Module, Desc),

lib/elixir/src/elixir_fn.erl

@@ -7,7 +7,7 @@
 fn(Meta, Clauses, S) ->
   Transformer = fun({ ArgsWithGuards, CMeta, Expr }, Acc) ->
     { Args, Guards } = elixir_clauses:extract_splat_guards(ArgsWithGuards),
-    elixir_clauses:assigns_block(?line(CMeta), fun elixir_translator:translate/2, Args, [Expr], Guards, umergec(S, Acc))
+    elixir_clauses:assigns_block(?line(CMeta), fun translate_fn_match/2, Args, [Expr], Guards, umergec(S, Acc))
   end,
 
   { TClauses, NS } = lists:mapfoldl(Transformer, S, Clauses),
@@ -21,6 +21,10 @@ fn(Meta, Clauses, S) ->
                    "cannot mix clauses with different arities in function definition")
   end.
 
+translate_fn_match(Arg, S) ->
+  { TArg, TS } = elixir_translator:translate(Arg, S#elixir_scope{extra=fn_match}),
+  { TArg, TS#elixir_scope{extra=S#elixir_scope.extra} }.
+
 capture(Meta, { '/', _, [{ { '.', _, [M, F] }, _ , [] }, A] }, S) when is_atom(F), is_integer(A) ->
   { [MF, FF, AF], SF } = elixir_translator:translate_args([M, F, A], S),
   { { 'fun', ?line(Meta), { function, MF, FF, AF } }, SF };

lib/elixir/src/elixir_macros.erl

@@ -281,7 +281,7 @@ translate_in(Meta, Left, Right, S) ->
     false -> { TLeft, SR }
   end,
 
-  { InGuard, TExpr } = case TRight of
+  { TCache, TExpr } = case TRight of
     { nil, _ } ->
       Expr = { atom, Line, false },
       { Cache, Expr };
@@ -322,7 +322,7 @@ translate_in(Meta, Left, Right, S) ->
       end
   end,
 
-  case InGuard of
+  case TCache of
     true  -> { Var, { block, Line, [ { match, Line, Var, TLeft }, TExpr ] }, SV };
     false -> { Var, TExpr, SV }
   end.

lib/elixir/src/elixir_translator.erl

@@ -346,10 +346,22 @@ translate_each({ 'super?', Meta, [] }, S) ->
 
 %% Variables
 
+translate_each({ '^', Meta, [ { Name, _, Kind } = Var ] },
+               #elixir_scope{extra=fn_match, extra_guards=Extra} = S) when is_atom(Name), is_atom(Kind) ->
+  case orddict:find({ Name, Kind }, S#elixir_scope.backup_vars) of
+    { ok, Value } ->
+      Line = ?line(Meta),
+      { TVar, TS } = translate_each(Var, S),
+      Guard = { op, Line, '=:=', { var, ?line(Meta), Value }, TVar },
+      { TVar, TS#elixir_scope{extra_guards=[Guard|Extra]} };
+    error ->
+      compile_error(Meta, S#elixir_scope.file, "unbound variable ^~ts", [Name])
+  end;
+
 translate_each({ '^', Meta, [ { Name, _, Kind } ] }, #elixir_scope{context=match} = S) when is_atom(Name), is_atom(Kind) ->
   case orddict:find({ Name, Kind }, S#elixir_scope.backup_vars) of
     { ok, Value } ->
-      { { var, Meta, Value }, S };
+      { { var, ?line(Meta), Value }, S };
     error ->
       compile_error(Meta, S#elixir_scope.file, "unbound variable ^~ts", [Name])
   end;

lib/elixir/test/elixir/kernel/fn_test.exs

@@ -4,6 +4,11 @@ defmodule Kernel.FnTest do
   use ExUnit.Case, async: true
   import CompileAssertion
 
+  test "clause with ^" do
+    x = 1
+    assert (fn ^x -> :ok; _ -> :error end).(1) == :ok
+  end
+
   test "capture remote" do
     assert (&:erlang.atom_to_list/1).(:a) == 'a'
     assert (&Kernel.atom_to_list/1).(:a) == 'a'

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

@@ -78,6 +78,23 @@ defmodule Kernel.WarningTest do
     purge Sample
   end
 
+  test :shadowing do
+    assert capture_err(fn ->
+      Code.eval_string """
+      defmodule Sample do
+        def test(x) do
+          case x do
+            {:file, fid} -> fid
+            {:path, _}   -> fn(fid) -> fid end
+          end
+        end
+      end
+      """
+    end) == nil
+  after
+    purge Sample
+  end
+
   test :unused_default_args do
     assert capture_err(fn ->
       Code.eval_string """