anchor.diff:      TempBefore=mk_old_code_temp(CaseExpr),
       UsedVars = all_vars(CaseExpr),
       {NewBody, Cond} = gen_new_body_and_cond(Body, UsedVars, try_expr),
  -    NewVars = collect_new_vars(Body, UsedVars),
  -    NewVarDefExprs = mk_new_var_define_exprs(NewVars),
  +    NewVars = collect_new_vars(remove_last_expr(Body), UsedVars),
  +    NewVarDefExprs = mk_new_var_define_exprs(NewVars,[]),
       TempAfter = mk_new_code_temp(NewBody, NewVars, 'META_RULE'),
       NewCode = wrangler_syntax:block_expr(NewVarDefExprs ++ [TempAfter]),
       Rule=mk_rule(RuleFunName,RuleMacroName, TempBefore, Cond, NewCode),
       {RuleFunName, Rule}.
   
   -spec(do_generate_simple_rule_for_try_expr({modulename(), functionname(),arity()},
  -                                            Pats::[syntaxTree()],Body::syntaxTree(),
  +                                           Pats::[syntaxTree()],Body::syntaxTree(),
                                              RuleMacroName::atom()) 
         -> {atom(), string()}).  
   do_generate_simple_rule_for_try_expr({M,F,_A},Pats,Body,RuleMacroName) ->
  
positive.code:             end;
          _ ->
              throw({error, mk_str("The last function clause body expression of the API interface function "
                           "~p:~p/~p is not supported by Wrangler.", [M,F,A])})
      end.
  
  valid_clause_body({M, F, A},Cs) ->
  
negative.code:                     throw({error,mk_str("API interface function ~p:~p/~p has non-variable parameters.",
                                   [M,F,A])});
                  true ->
                      Body = wrangler_syntax:clause_body(C),
                      case Body of 
                          [_] ->
                              do_process_api_interface_funs_2(OldAPIModName,Form);
                          _ ->
                              %% This condition could be relaxed.
                              throw({error, mk_str("API interface function  ~p:~p/~p contains more than one expression"
                                                   " statement in the function clause body.",
                                                   [M,F,A])})
                      end
              end;
          _ ->
              throw({error, mk_str("API interface function ~p:~p/~p has more than one "
                                   "function clause.",
                                   [M, F, A])})
      end.
  
  -spec(do_process_api_interface_funs_2(OldAPIModName :: atom(),
                                        Form :: syntaxTree()) -> 
               {[{modulename(), functionname(),
                  arity()}],
                [{functionname(), string()}],
                [{functionname(), string()}]}).
  do_process_api_interface_funs_2(OldAPIModName, Form) ->
      {M,F,A} = api_refac:fun_define_info(Form),
      [C] = wrangler_syntax:function_clauses(Form),
  