anchor.diff:    {ELeft, EL}  = Fun(Left, E),
     {ERight, ER} = elixir_expand:expand(Right, EL#{export_vars := ExportVars}),
     {{'->', Meta, [ELeft, ERight]}, ER};
  -clause(Meta, {Kind, Key}, _Fun, _, E) ->
  -  compile_error(Meta, ?key(E, file), "expected -> clauses for ~ts in ~ts", [Key, Kind]);
   clause(Meta, Kind, _Fun, _, E) ->
  -  compile_error(Meta, ?key(E, file), "expected -> clauses in ~ts", [Kind]).
  +  form_error(Meta, ?key(E, file), ?MODULE, {bad_or_missing_clauses, Kind}).
   
   head([{'when', Meta, [_, _ | _] = All}], E) ->
     {Args, Guard} = elixir_utils:split_last(All),
  
positive.code:   Fun = expand_one(Meta, 'case', 'do', fun head/2),
    expand_with_export(Meta, 'case', Fun, Do, Acc, E);
  expand_case(Meta, {Key, _}, _Acc, E) ->
    compile_error(Meta, ?key(E, file), "unexpected keyword ~ts in case", [Key]).
  
  %% Cond
  
  'cond'(Meta, [], E) ->
    compile_error(Meta, ?key(E, file), "missing do keyword in cond");
  'cond'(Meta, Opts, E) when not is_list(Opts) ->
    compile_error(Meta, ?key(E, file), "invalid arguments for cond");
  'cond'(Meta, Opts, E) ->
    ok = assert_at_most_once('do', Opts, 0, fun(Kind) ->
      compile_error(Meta, ?key(E, file), "duplicated ~ts clauses given for cond", [Kind])
    end),
    EE = E#{export_vars := []},
    {EClauses, EVars} = lists:mapfoldl(fun(X, Acc) -> expand_cond(Meta, X, Acc, EE) end, [], Opts),
  
negative.code:   Fun = expand_one(Meta, 'receive', 'after', fun elixir_expand:expand_args/2),
    expand_with_export(Meta, 'receive', Fun, After, Acc, E);
  expand_receive(Meta, {'after', _}, _Acc, E) ->
    form_error(Meta, ?key(E, file), ?MODULE, multiple_after_clauses_in_receive);
  expand_receive(Meta, {Key, _}, _Acc, E) ->
    form_error(Meta, ?key(E, file), ?MODULE, {unexpected_keyword, 'receive', Key}).
  
  %% Try
  
  'try'(Meta, [], E) ->
    form_error(Meta, ?key(E, file), ?MODULE, {missing_do, 'try'});
  'try'(Meta, [{do, _}], E) ->
    form_error(Meta, ?key(E, file), ?MODULE, missing_keyword_in_try);
  'try'(Meta, Opts, E) when not is_list(Opts) ->
    form_error(Meta, ?key(E, file), ?MODULE, {invalid_args, 'try'});
  'try'(Meta, Opts, E) ->
    RaiseError = fun(Key) ->
      form_error(Meta, ?key(E, file), ?MODULE, {duplicated_clauses, 'try', Key})
    end,
    ok = assert_at_most_once('do', Opts, 0, RaiseError),
    ok = assert_at_most_once('rescue', Opts, 0, RaiseError),
  