anchor.diff:                                _ -> wrangler_syntax:type(Expr@)
                             end,
                             true)], B).
  -        
  +
   
   -spec(do_generate_rule_for_application({modulename(), functionname(),arity()},
                                          Pats::[syntaxTree()],Body::syntaxTree()) ->
  
positive.code:                     throw({error,mk_str("API interface function ~p:~p/~p has non-variable parameters.",
                                   [M,F,A])});
                  true ->
                      Guard = wrangler_syntax:clause_guard(C),
                      case Guard of 
                          none ->
                              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;
                          _ ->throw({error, mk_str("API interface function  ~p:~p/~p contains a function clause with guard.",
                                           [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),
  
negative.code:     {NewC, []};
  gen_new_clause_and_cond(C, Nth,_BeforeTempType) ->
      Pats = wrangler_syntax:clause_patterns(C),
      Guard0 = wrangler_syntax:clause_guard(C),
      GuardName = list_to_atom("Guard" ++ integer_to_list(Nth) ++ "@@"),
      Guard = if Guard0 == none -> 
                      wrangler_syntax:variable(GuardName);
                 true ->[Guard0, wrangler_syntax:variable(GuardName)]
              end,
      LastBody = wrangler_syntax:variable(list_to_atom("Body"++integer_to_list(Nth)++"@@")),
      Bs = wrangler_syntax:clause_body(C),
      NewC=wrangler_syntax:clause(Pats, Guard, lists:reverse([LastBody|tl(lists:reverse(Bs))])),
  