anchor.diff:  
   
   %% =====================================================================
  -% @doc Attach syntax category information to AST nodes of functions.
  +% @doc Attach syntax category information to an AST node if the node 
  +%%     represents a pattern, expression or guard_expression.
   %% =====================================================================
  -%% -type (category():: pattern|expression|guard_expression|record_type|record_field|
  -%%                     generator|{macro_name, none|int()|pattern|expression}|macro_arg|
  -%%                     operator|name|arity|binary_field).
  -%%-spec(add_category(Node::syntaxTree()) -> syntaxTree()).
  +%% -type (category():: pattern|expression|guard_expression).
  +-spec(add_category(Node::syntaxTree()) -> syntaxTree()).
   add_category(Node) ->
       add_category(Node, none).
   
  
positive.code: 			  end,
              SyntaxTree = refac_recomment:recomment_forms(Forms, []),
              Info = refac_syntax_lib:analyze_forms(SyntaxTree),
  	    Info2 = merge_module_info(Info0, Info),
  	    AnnAST0 = annotate_bindings(FName, SyntaxTree, Info2, Ms, TabWidth),
              AnnAST = refac_atom_annotation:type_ann_ast(FName, Info2, AnnAST0, SearchPaths, TabWidth),
  	    {ok, {AnnAST, Info2}};
  	{error, Reason} -> erlang:error(Reason)
  
negative.code: 	     {functions, F(functions)}, {rules, F(rules)}],
      [{A,V}||{A, V}<-NewInfo, V=/=[]].
  
  
  update_module_info(ModInfo) ->
      ModInfo1 = update_exports(ModInfo),
      update_inscope_funs(ModInfo1).
    
  update_exports(ModInfo) ->
      case lists:keysearch(attributes,1, ModInfo) of 
          {value, {attributes, Attrs}} ->
              case lists:member({compile, export_all}, Attrs) of
                  true ->
                      case  lists:keysearch(functions,1, ModInfo) of
                          {value, {functions, Funs}} ->
                              case lists:keysearch(exports, 1, ModInfo) of
                                  {value, {exports, Funs1}} ->
                                      lists:keyreplace(exports, 1, ModInfo, 
                                                       {exports, lists:usort(Funs++Funs1)});
                                  false ->
                                      ModInfo++[{exports, Funs}]
                              end;
                          false->
                              ModInfo
                      end;
                  false ->
                      ModInfo
              end;
          false ->
              ModInfo
      end.
          
  update_inscope_funs(ModInfo) ->
      Imps =  case lists:keysearch(imports, 1, ModInfo) of
                  {value, {imports, Funs}} ->
                      Funs;
                  _ -> []
              end,
      DefinedFuns = case lists:keysearch(functions, 1, ModInfo) of
                        {value, {functions, Fs}} ->
                         Fs;
                        _ -> []
                    end,
      PreDefinedFuns = [{module_info, 1}, {module_info, 2}, {record_info, 2}],
      AutoImps = auto_imported_bifs(),
      NoAutoImps =case lists:keysearch(attributes, 1, ModInfo) of
                       {value, {attributes, Attrs}} ->
                           [{F, list_to_integer(A)}||{compile, {no_auto_import, FAs}}<-Attrs,
                                                     {F,A}<-FAs];
                       _ -> []
                   end,
      InScopeFuns =Imps++DefinedFuns++PreDefinedFuns++(AutoImps--NoAutoImps),
      ModInfo++[{inscope_funs, InScopeFuns}].
  
  
  auto_imported_bifs() ->
      [{abs, 1},            {apply, 2},             {apply, 3}, 
       {atom_to_binary, 2}, {binary_part, 2},       {binary_part, 3},
       {binary_to_atom, 2}, {binary_to_existing_atom,2},
       {atom_to_list, 1},   {binary_to_list, 1},    {binary_to_list, 3}, 
       {bitstring_to_list,1}, {binary_to_term, 1},  {bit_size, 1},
       {byte_size, 1},
       {binary_to_term, 2}, {check_process_code,2}, {concat_binary, 1},  
       {date, 3},           {delete_module, 1},     {demonitor, 1},
       {demonitor, 2},      {disconnect_node, 1},   {error, 1},
       {error, 2},
       {element, 2},        {erase, 0},             {erase, 1}, 
       {exit, 1},           {exit, 2},              {float, 1},
       {float_to_list, 1},  {garbage_collect, 1},   {garbage_collect, 0},
       {get, 0},            {get, 1},               {get_keys, 1},  
       {group_leader, 0},   {group_leader, 2},      {halt, 0},
       {halt, 1},           {hd, 1},                {integer_to_list, 1},
       {integer_to_list,2}, {iolist_to_binary,1},   {iolist_size, 1}, 
       {is_alive, 0},       {is_atom, 1},           {is_bitstring,1},
       {is_binary, 1},      {is_boolean, 1},        {is_float, 1},
       {is_function, 1},    {is_function, 2},       {is_integer, 1},
       {is_list, 1},        {is_number, 1},         {is_pid, 1},
       {is_port, 1},        {is_process_alive,1},   {is_record, 2},  
       {is_record, 3},      {is_reference, 1},      {is_tuple, 1},    
       {length, 1},         {link, 1},              {list_to_atom, 1},
       {list_to_binary,1},  {list_to_bitstring, 1},
       {list_to_float, 1},  {list_to_existing_atom,1}, 
       {list_to_integer,1}, {list_to_pid, 1},       {list_to_tuple, 1},
       {load_module, 2},    {make_ref, 0},          {max, 2},
       {min, 2},            {module_loaded, 1},     {monitor, 2},
       {monitor_node, 2},   {node, 0},              {node, 1},   
       {nodes, 0},          {nodes, 1},             {now, 0},
       {open_port, 2},      {pid_to_list, 1},       {port_close, 1},  
       {port_command, 2},   {port_command, 3},
       {port_connect, 2},   {port_control, 3},  
       {pre_loaded, 0},     {process_flag, 2},      {process_flag, 3},
       {process_info, 1},   {process_info, 2},      {processes, 0},
       {purge_module, 1},   {put, 2},               {register, 2},    
       {registered, 0},     {round, 1},             {self, 0},
       {setelement, 3},     {size, 1},              {spawn, 1},
       {spawn, 2},          {spawn, 3},             {spawn, 4},    
       {spawn_link, 1},     {spawn_link, 2},        {spawn_link, 3},
       {spawn_link, 4},     {spawn_monitor, 1},     {spawn_monitor, 3},
       {spawn_opt, 2},      {spawn_opt, 3},
       {spawn_opt, 4},      {spawn_opt, 5},         {aplit_binary, 2}, 
       {statistics, 1},     {term_to_binary, 1},    {term_to_binary, 2},
       {throw, 1},          {time, 1},              {tl, 1},
       {trunc, 1},          {tuple_size, 1},        {tuple_to_list, 1},
       {unregister, 1},     {unregister, 1},        {unlink, 1}, 
       {whereis, 1}].
  
  annotate_bindings(FName, AST, Info, Ms, TabWidth) ->
      Toks = refac_util:tokenize(FName, true, TabWidth),
      AnnAST = add_token_and_ranges(AST, Toks), 
      AnnAST0 = refac_syntax_lib:annotate_bindings(AnnAST,ordsets:new(), Ms),
      Comments = refac_comment_scan:file(FName, TabWidth),
      AnnAST1= refac_recomment:recomment_forms(AnnAST0, Comments),
      AnnAST2 =update_toks(Toks,AnnAST1),
  