Support (x, y) when z, closes #1313

Author: José Valim

lib/elixir/lib/macro.ex

@@ -248,6 +248,12 @@ defmodule Macro do
     op_to_string(left) <> " #{op} " <> op_to_string(right)
   end
 
+  # Splat when
+  def to_string({ :when, _, args }) do
+    { left, right } = :elixir_tree_helpers.split_last(args)
+    "(" <> Enum.map_join(left, ", ", to_string(&1)) <> ") when " <> to_string(right)
+  end
+
   # Unary ops
   def to_string({ :not, _, [arg] })  do
     "not " <> to_string(arg)

lib/elixir/src/elixir_clauses.erl

@@ -2,7 +2,7 @@
 %% fn, receive and friends. try is handled in elixir_try.
 -module(elixir_clauses).
 -export([
-  assigns/3, assigns_block/5, assigns_block/6, extract_last_guards/1,
+  assigns/3, assigns_block/5, assigns_block/6, extract_splat_guards/1,
   get_pairs/4, get_pairs/5, match/3, extract_args/1, extract_guards/1]).
 -include("elixir.hrl").
 
@@ -80,13 +80,13 @@ extract_args({ Name, _, Args }) when is_atom(Name), is_atom(Args) -> { Name, []
 extract_args({ Name, _, Args }) when is_atom(Name), is_list(Args) -> { Name, Args };
 extract_args(_) -> error.
 
-% Extract guards when it is in the last element of the args
+% Extract guards when multiple left side args are allowed.
 
-extract_last_guards([]) -> { [], [] };
-extract_last_guards(Args) ->
-  { Left, Right }  = elixir_tree_helpers:split_last(Args),
-  { Bare, Guards } = extract_guards(Right),
-  { Left ++ [Bare], Guards }.
+extract_splat_guards([{ 'when', _, [_,_|_] = Args }]) ->
+  { Left, Right } = elixir_tree_helpers:split_last(Args),
+  { Left, extract_or_clauses(Right, []) };
+extract_splat_guards(Else) ->
+  { Else, [] }.
 
 % Function for translating macros with match style like case and receive.
 

lib/elixir/src/elixir_parser.yrl

@@ -218,8 +218,12 @@ stab_eol -> stab eol : '$1'.
 
 stab_expr -> expr : '$1'.
 stab_expr -> stab_op stab_maybe_expr : build_op('$1', [], '$2').
-stab_expr -> call_args_no_parens stab_op stab_maybe_expr : build_op('$2', unwrap_splice('$1'), '$3').
-stab_expr -> call_args_parens_not_one stab_op stab_maybe_expr : build_op('$2', unwrap_splice('$1'), '$3').
+stab_expr -> call_args_no_parens stab_op stab_maybe_expr :
+               build_op('$2', unwrap_when(unwrap_splice('$1')), '$3').
+stab_expr -> call_args_parens_not_one stab_op stab_maybe_expr :
+               build_op('$2', unwrap_splice('$1'), '$3').
+stab_expr -> call_args_parens_not_one when_op matched_expr stab_op stab_maybe_expr :
+               build_op('$4', [{ 'when', [{line,?line('$2')}], unwrap_splice('$1') ++ ['$3'] }], '$5').
 
 stab_maybe_expr -> 'expr' : '$1'.
 stab_maybe_expr -> '$empty' : nil.
@@ -239,7 +243,7 @@ open_paren -> '(' eol  : '$1'.
 close_paren -> ')'     : '$1'.
 close_paren -> eol ')' : '$2'.
 
-empty_paren -> open_paren ')' : nil.
+empty_paren -> open_paren ')' : '$1'.
 
 open_bracket  -> '['     : '$1'.
 open_bracket  -> '[' eol : '$1'.
@@ -394,15 +398,15 @@ matched_comma_expr -> matched_expr : ['$1'].
 matched_comma_expr -> matched_comma_expr ',' matched_expr : ['$3'|'$1'].
 
 call_args_no_parens_strict -> call_args_no_parens : '$1'.
-call_args_no_parens_strict -> open_paren ')' : throw_no_parens_strict('$1').
+call_args_no_parens_strict -> empty_paren : throw_no_parens_strict('$1').
 call_args_no_parens_strict -> open_paren matched_kw_base close_paren : throw_no_parens_strict('$1').
 call_args_no_parens_strict -> open_paren matched_expr ',' call_args_no_parens close_paren : throw_no_parens_strict('$1').
 
 call_args_no_parens -> matched_comma_expr : lists:reverse('$1').
 call_args_no_parens -> matched_kw_base : ['$1'].
 call_args_no_parens -> matched_comma_expr ',' matched_kw_base : lists:reverse(['$3'|'$1']).
 
-call_args_parens_not_one -> open_paren ')' : [].
+call_args_parens_not_one -> empty_paren : [].
 call_args_parens_not_one -> open_paren matched_kw_base close_paren : ['$2'].
 call_args_parens_not_one -> open_paren matched_expr ',' call_args_no_parens close_paren : ['$2'|'$4'].
 
@@ -420,7 +424,7 @@ optional_comma_expr -> paren_expr ',' : '$1'.
 
 call_args -> comma_expr : lists:reverse('$1').
 
-call_args_parens -> open_paren ')' : [].
+call_args_parens -> empty_paren : [].
 call_args_parens -> open_paren call_args close_paren : '$2'.
 
 % KV
@@ -597,7 +601,7 @@ build_stab(Meta, [], Marker, Temp, Acc) ->
 
 %% Every time the parser sees a (unquote_splicing())
 %% it assumes that a block is being spliced, wrapping
-%% the splicing in a __block__. But in the stab cause,
+%% the splicing in a __block__. But in the stab clause,
 %% we can have (unquote_splicing(1,2,3)) -> :ok, in such
 %% case, we don't actually want the block, since it is
 %% an arg style call. unwrap_splice unwraps the splice
@@ -607,6 +611,14 @@ unwrap_splice([{ '__block__', [], [{ unquote_splicing, _, _ }] = Splice }]) ->
 
 unwrap_splice(Other) -> Other.
 
+unwrap_when(Args) ->
+  case elixir_tree_helpers:split_last(Args) of
+    { Start, { 'when', Meta, [_, _] = End } } ->
+      [{ 'when', Meta, Start ++ End }];
+    { _, _ } ->
+      Args
+  end.
+
 %% Errors
 
 throw(Line, Error, Token) ->

lib/elixir/src/elixir_translator.erl

@@ -551,7 +551,7 @@ no_alias_expansion(Other) ->
 
 translate_fn(Meta, Clauses, S) ->
   Transformer = fun({ ArgsWithGuards, CMeta, Expr }, Acc) ->
-    { Args, Guards } = elixir_clauses:extract_last_guards(ArgsWithGuards),
+    { 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))
   end,
 

lib/elixir/src/elixir_try.erl

@@ -10,7 +10,7 @@ clauses(Meta, Clauses, S) ->
   lists:mapfoldl(Transformer, S, Rescue ++ Catch).
 
 each_clause({ 'catch', Meta, Raw, Expr }, S) ->
-  { Args, Guards } = elixir_clauses:extract_last_guards(Raw),
+  { Args, Guards } = elixir_clauses:extract_splat_guards(Raw),
 
   Final = case Args of
     [X]     -> [throw, X, { '_', Meta, nil }];
@@ -23,19 +23,19 @@ each_clause({ 'catch', Meta, Raw, Expr }, S) ->
   Condition = { '{}', Meta, Final },
   elixir_clauses:assigns_block(?line(Meta), fun elixir_translator:translate_each/2, Condition, [Expr], Guards, S);
 
-each_clause({ rescue, Meta, [Condition|T], Expr }, S) ->
+each_clause({ rescue, Meta, [Condition], Expr }, S) ->
   case normalize_rescue(Meta, Condition, S) of
     { Left, Right } ->
       case Left of
         { '_', _, _ } ->
           { ClauseVar, CS } = elixir_scope:build_ex_var(?line(Meta), S),
           { Clause, _ } = rescue_guards(Meta, ClauseVar, Right, S),
-          each_clause({ 'catch', Meta, [error, Clause|T], Expr }, CS);
+          each_clause({ 'catch', Meta, Clause, Expr }, CS);
         _ ->
           { Clause, Safe } = rescue_guards(Meta, Left, Right, S),
           case Safe of
             true ->
-              each_clause({ 'catch', Meta, [error, Clause|T], Expr }, S);
+              each_clause({ 'catch', Meta, Clause, Expr }, S);
             false ->
               { ClauseVar, CS }  = elixir_scope:build_ex_var(?line(Meta), S),
               { FinalClause, _ } = rescue_guards(Meta, ClauseVar, Right, S),
@@ -44,11 +44,11 @@ each_clause({ rescue, Meta, [Condition|T], Expr }, S) ->
                 { { '.', Meta, ['Elixir.Exception', normalize] }, Meta, [ClauseVar] }
               ] },
               FinalExpr = prepend_to_block(Meta, Match, Expr),
-              each_clause({ 'catch', Meta, [error, FinalClause|T], FinalExpr }, CS)
+              each_clause({ 'catch', Meta, FinalClause, FinalExpr }, CS)
           end
       end;
     _ ->
-      each_clause({ 'catch', Meta, [error, Condition|T], Expr }, S)
+      each_clause({ 'catch', Meta, [error, Condition], Expr }, S)
   end;
 
 each_clause({rescue,Meta,_,_}, S) ->
@@ -97,7 +97,7 @@ normalize_rescue(Meta, Condition, S) ->
   end.
 
 %% Convert rescue clauses into guards.
-rescue_guards(_, Var, nil, _) -> { Var, false };
+rescue_guards(_, Var, nil, _) -> { [error, Var], false };
 
 rescue_guards(Meta, Var, Guards, S) ->
   { RawElixir, RawErlang } = rescue_each_var(Meta, Var, Guards),
@@ -114,7 +114,7 @@ rescue_guards(Meta, Var, Guards, S) ->
       [join(Meta, 'and', [IsTuple, IsException, OrElse])|Erlang]
   end,
   {
-    { 'when', Meta, [Var, reverse_join(Meta, 'when', Final)] },
+    [{ 'when', Meta, [error, Var, reverse_join(Meta, 'when', Final)] }],
     Safe
   }.
 

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -112,6 +112,11 @@ defmodule Kernel.QuoteTest do
     assert fun.(1, 2, 3) == :ok
   end
 
+  test :when do
+    assert {:->,_,[{[{:when,_,[1,2,3,4]}],_,5}]} = quote(do: (1, 2, 3 when 4 -> 5))
+    assert {:->,_,[{[{:when,_,[1,2,3,4]}],_,5}]} = quote(do: ((1, 2, 3) when 4 -> 5))
+  end
+
   test :stab do
     assert { :->, _, [{[], _, _}] } = (quote do -> end)
     assert { :->, _, [{[], _, _}] } = (quote do: (->))

lib/elixir/test/elixir/macro_test.exs

@@ -252,7 +252,6 @@ defmodule MacroTest do
   end
 
   test :fn_to_binary do
-    assert Macro.to_string(quote do: (() -> x)) == "(() -> x)"
     assert Macro.to_string(quote do: (fn -> 1 + 2 end)) == "fn -> 1 + 2 end"
     assert Macro.to_string(quote do: (fn(x) -> x + 1 end)) == "fn x -> x + 1 end"
 
@@ -274,6 +273,13 @@ defmodule MacroTest do
     """
   end
 
+  test :when do
+    assert Macro.to_string(quote do: (() -> x)) == "(() -> x)"
+    assert Macro.to_string(quote do: (x when y -> z)) == "(x when y -> z)"
+    assert Macro.to_string(quote do: (x, y when z -> w)) == "((x, y) when z -> w)"
+    assert Macro.to_string(quote do: ((x, y) when z -> w)) == "((x, y) when z -> w)"
+  end
+
   test :partial_to_binary do
     assert Macro.to_string(quote do: identity(&1)) == "identity(&1)"
   end