anchor.diff:    {TExpr, SE}  = elixir_erl_pass:translate(wrap_expr(Expr, TInto), SC),
     SF = elixir_erl_var:mergec(SI, SE),
   
  -  case comprehension_expr(TInto, TExpr) of
  -    {inline, TIntoExpr} ->
  -      build_inline(Ann, TCases, TIntoExpr, TInto, TUniq, SF);
  -    {into, TIntoExpr} ->
  -      build_into(Ann, TCases, TIntoExpr, TInto, TUniq, SF)
  +  case inline_or_into(TInto) of
  +    inline -> build_inline(Ann, TCases, TExpr, TInto, TUniq, SF);
  +    into -> build_into(Ann, TCases, TExpr, TInto, TUniq, SF)
     end.
   
   %% In case we have no return, we wrap the expression
  
positive.code:   collect_filters(T, [H | Acc]);
  collect_filters([], Acc) ->
    {Acc, []}.
  
  
  build_inline(Ann, Clauses, Expr, Into, Uniq, S) ->
    case not Uniq and lists:all(fun(Clause) -> element(1, Clause) == bin end, Clauses) of
  
negative.code: comprehension_clause([]) ->
    [].
  
  comprehension_kind(false) -> lc;
  comprehension_kind({nil, _}) -> lc;
  comprehension_kind({bin, _, []}) -> bc.
  
  comprehension_generator(enum) -> generate;
  comprehension_generator(bin) -> b_generate.
  
  inline_or_into({bin, _, []}) -> inline;
  inline_or_into({nil, _}) -> inline;
  inline_or_into(false) -> inline;
  inline_or_into(_) -> into.
  
  comprehension_filter(Ann, Filters) ->
    [join_filter(Ann, Filter, {atom, Ann, true}, {atom, Ann, false}) ||
  