anchor.diff:              {files, Files}],
       run_dialyzer(State, Opts).
   
  -succ_typings(State, Plt, Apps) ->
  +succ_typings(State, Plt) ->
       {Args, _} = rebar_state:command_parsed_args(State),
       case proplists:get_value(succ_typings, Args) of
           false ->
               {0, State};
           _ ->
  -            do_succ_typings(State, Plt, Apps)
  -    end.
  -
  -do_succ_typings(State, Plt, Apps) ->
  +            Apps = rebar_state:project_apps(State),
  +            succ_typings(State, Plt, Apps)
  +    end.
  +
  +succ_typings(State, Plt, Apps) ->
       ?INFO("Doing success typing analysis...", []),
  -    Files = apps_to_files(Apps),
  +    {Files, Warnings} = apps_to_files(Apps),
  +    Warnings2 = format_warnings(Warnings),
       ?INFO("Analyzing ~b files with ~p...", [length(Files), Plt]),
       Opts = [{analysis_type, succ_typings},
               {get_warnings, true},
               {from, byte_code},
               {files, Files},
               {init_plt, Plt}],
  -    run_dialyzer(State, Opts).
  +    {Warnings3, State2} = run_dialyzer(State, Opts),
  +    {Warnings2 + Warnings3, State2}.
   
   apps_to_files(Apps) ->
  -    lists:flatmap(fun app_to_files/1, Apps).
  +    ?INFO("Resolving files...", []),
  +    Result = [{Files, Warnings} ||
  +              App <- Apps,
  +              {Files, Warnings} <- [app_to_files(App)]],
  +    Files = [File || {Files, _} <- Result, File <- Files],
  +    Warnings = [Warning || {_, Warnings} <- Result, Warning <- Warnings],
  +    {Files, Warnings}.
   
   app_to_files(App) ->
       AppName = ec_cnv:to_atom(rebar_app_info:name(App)),
  -    {_, Files} = app_name_to_info(AppName),
  -    Files.
  +    {_, Files, Warnings} = app_name_to_info(AppName),
  +    {Files, Warnings}.
   
   run_dialyzer(State, Opts) ->
       %% dialyzer may return callgraph warnings when get_warnings is false
  
positive.code: 
  build_proj_plt(State, Plt, Files) ->
      BasePlt = get_base_plt_location(State),
      BaseFiles = get_base_plt_files(State),
      {BaseWarnings, State1} = update_base_plt(State, BasePlt, BaseFiles),
      ?INFO("Copying ~p to ~p...", [BasePlt, Plt]),
      _ = filelib:ensure_dir(Plt),
      case file:copy(BasePlt, Plt) of
          {ok, _} ->
              {CheckWarnings, State2} = check_plt(State1, Plt, BaseFiles, Files),
              {BaseWarnings + CheckWarnings, State2};
          {error, Reason} ->
              Error = io_lib:format("Could not copy PLT from ~p to ~p: ~p",
                                    [BasePlt, Plt, file:format_error(Reason)]),
  
negative.code: app_name_to_info(AppName) ->
      case app_name_to_ebin(AppName) of
          {error, _} ->
              {[], [], [{unknown_application, {"", 0}, [AppName]}]};
          EbinDir ->
              ebin_to_info(EbinDir, AppName)
      end.
  