anchor.diff:                      {line, integer_to_list(Line)}]}
            end ||{{M, F, A}, {File, Line}}<-LongFuns],
       {ok, Res}.
  +
  +-spec large_modules(integer(), [dir()|filename()]) ->
  +                            {ok, [{message(), [{tag(), list()}]}]}.
  +large_modules(Lines, SearchPaths) ->
  +    {ok, LargeMods}= wrangler_code_inspector_lib:large_modules(Lines, SearchPaths, 8),
  +    Res = [begin
  +               M=filename:basename(File, ".erl"),
  +               Msg=lists:flatten(
  +                     io_lib:format("The module '~p' has more than ~p "
  +                                 "lines of code.", [list_to_atom(M), Lines])),
  +               {Msg, [{file, File}]} 
  +           end ||File<-LargeMods],
  +    {ok, Res}.
  +
  +-spec nested_case_exprs(integer(), [dir()|filename()]) ->
  +                            {ok, [{message(), [{tag(), list()}]}]}.
  +nested_case_exprs(NestLevel, SearchPaths) ->
  +    nested_exprs(NestLevel, SearchPaths, 'case').
  +
  +-spec nested_if_exprs(integer(), [dir()|filename()]) ->
  +                               {ok, [{message(), [{tag(), list()}]}]}.
  +nested_if_exprs(NestLevel, SearchPaths) ->
  +    nested_exprs(NestLevel, SearchPaths, 'if').
  +
  +-spec nested_receive_exprs(integer(), [dir()|filename()]) ->
  +                               {ok, [{message(), [{tag(), list()}]}]}.
  +nested_receive_exprs(NestLevel, SearchPaths) ->
  +    nested_exprs(NestLevel, SearchPaths, 'receive').
  +
  +nested_exprs(NestLevel, SearchPaths, ExprType) ->
  +    Files = wrangler_misc:expand_files(SearchPaths, ".erl"),
  +    Funs = lists:flatmap(fun (File) ->
  +				 ResRanges=wrangler_code_inspector_lib:nested_exprs_1(
  +                                             File, NestLevel, ExprType, SearchPaths, 8),
  +                                 [{File, M, F, A, Ln}||{M,F, A, {{Ln, _},_}}<-ResRanges]
  +			 end, Files),
  +    Res = [begin
  +               Msg = lists:flatten(
  +                       io_lib:format("The ~p expression in function ~p:~p/~p is nested ~p times or more.",
  +                                     [ExprType, M, F, A, NestLevel])),
  +               {Msg, [{file, File},
  +                      {line, integer_to_list(Ln)}]}
  +           end || {File, M, F, A, Ln}<-Funs],
  +    {ok, Res}.
  +    
  +-spec not_flush_unknown_messages([dir()|filename()]) ->
  +                                        {ok, [{message(), [{tag(), list()}]}]}.
  +not_flush_unknown_messages(SearchPaths) ->
  +    Files = wrangler_misc:expand_files(SearchPaths, ".erl"),
  +    Funs = lists:flatmap(fun (F) ->
  +				 wrangler_code_inspector_lib:not_flush_unknown_messages_1(F, SearchPaths, 8)
  +			 end, Files),
  +    Res = [begin
  +               Msg = lists:flatten(
  +                       io_lib:format("The receive expression in function ~p:~p/~p does not flush unknown messages.",
  +                                     [M, F, A])),
  +               {Msg, [{file, File},
  +                      {line, integer_to_list(Ln)}]}
  +           end || {File, M, F, A, Ln}<-Funs],
  +    {ok, Res}.
  +    
   
   -spec calls_to_specific_function(mfa(), [dir()|filename()]) ->    
                                           {ok, [{message(), [{tag(), list()}]}]}.
  
positive.code:     end.
      
  -spec overall_classify([atom()]) -> atom().
  
  overall_classify([]) ->
       none;
  overall_classify([X|Xs]) ->
  
negative.code: 
  -export([do_code_inspection/2]).
  
  %% API for feedback tool.
  -export([long_functions/2, 
           large_modules/2,
           calls_to_specific_function/2,
           classify_pattern_match/1, 
           nested_if_exprs/2,
           nested_case_exprs/2,
           nested_receive_exprs/2,
           not_flush_unknown_messages/1,
           top_level_if/1,
           unnecessary_match/1,
           append_two_lists/1,
           non_tail_recursive_function/1
          ]).
  
  -export([test/1,
  	 collect_function_apps/2,
  	 collect_function_apps2/2]).
  
  