Avoid generating accumulator for nested comprehensions

Closes #4013

Author: José Valim

lib/elixir/src/elixir_for.erl

@@ -67,7 +67,7 @@ translate(Meta, Args, Return, S) ->
     end,
 
   {TCases, SC} = translate_gen(Meta, Cases, [], SI),
-  {TExpr, SE}  = elixir_translator:translate(Expr, SC),
+  {TExpr, SE}  = elixir_translator:translate(wrap_expr(Expr, TInto), SC),
   SF = elixir_scope:mergec(SI, SE),
 
   case comprehension_expr(TInto, TExpr) of
@@ -77,6 +77,11 @@ translate(Meta, Args, Return, S) ->
       build_into(Ann, TCases, TIntoExpr, TInto, Var, Acc, SF)
   end.
 
+%% In case we have no return, we wrap the expression
+%% in a block that returns nil.
+wrap_expr(Expr, false) -> {'__block__', [], [Expr, nil]};
+wrap_expr(Expr, _)  -> Expr.
+
 translate_gen(ForMeta, [{'<-', Meta, [Left, Right]}|T], Acc, S) ->
   {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),
   TAcc = [{enum, Meta, TLeft, TRight, TFilters}|Acc],
@@ -253,10 +258,7 @@ no_var_expr({var, Ann, _}) ->
   {var, Ann, '_'}.
 
 build_comprehension(Ann, Clauses, Expr, false) ->
-  {block, Ann, [
-    build_comprehension(Ann, Clauses, Expr, {nil, Ann}),
-    {nil, Ann}
-  ]};
+  {lc, Ann, Expr, comprehension_clause(Clauses)};
 build_comprehension(Ann, Clauses, Expr, Into) ->
   {comprehension_kind(Into), Ann, Expr, comprehension_clause(Clauses)}.
 

lib/elixir/src/elixir_translator.erl

@@ -363,6 +363,8 @@ translate_block([], Acc, S) ->
 translate_block([H], Acc, S) ->
   {TH, TS} = translate(H, S),
   translate_block([], [TH|Acc], TS);
+translate_block([{'__block__', _Meta, Args}|T], Acc, S) when is_list(Args) ->
+  translate_block(Args ++ T, Acc, S);
 translate_block([{for, Meta, [_|_] = Args}|T], Acc, S) ->
   {TH, TS} = elixir_for:translate(Meta, Args, false, S),
   translate_block(T, [TH|Acc], TS);