anchor.diff:  
   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),
  +    {BaseFiles, BaseWarnings} = base_plt_files(State),
  +    BaseWarnings2 = format_warnings(BaseWarnings),
  +    {BaseWarnings3, 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};
  +            {BaseWarnings2 + BaseWarnings3 + CheckWarnings, State2};
           {error, Reason} ->
               Error = io_lib:format("Could not copy PLT from ~p to ~p: ~p",
                                     [BasePlt, Plt, file:format_error(Reason)]),
  
positive.code: app_name_to_info(AppName) ->
      case app_name_to_ebin(AppName) of
          {error, _} ->
              ?CONSOLE("Unknown application ~s", [AppName]),
              {[], []};
          EbinDir ->
              ebin_to_info(EbinDir, AppName)
      end.
  
negative.code:             {files, Files}],
      run_dialyzer(State, Opts).
  
  succ_typings(State, Plt) ->
      {Args, _} = rebar_state:command_parsed_args(State),
      case proplists:get_value(succ_typings, Args) of
          false ->
              {0, State};
          _ ->
              Apps = rebar_state:project_apps(State),
              succ_typings(State, Plt, Apps)
      end.
  
  succ_typings(State, Plt, Apps) ->
      ?INFO("Doing success typing analysis...", []),
      {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}],
      {Warnings3, State2} = run_dialyzer(State, Opts),
      {Warnings2 + Warnings3, State2}.
  
  apps_to_files(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, Warnings} = app_name_to_info(AppName),
      {Files, Warnings}.
  
  run_dialyzer(State, Opts) ->
      %% dialyzer may return callgraph warnings when get_warnings is false
  