anchor.diff:      rebar_base_compiler:run(
         Config, FirstErls, OtherErls,
         fun(S, C) ->
  -        ErlOpts1 = case lists:member(S, ErlFirstFiles) of
  -            true -> ErlOptsFirst;
  -            false -> ErlOpts
  -        end,
  -        internal_erl_compile(C, S, OutDir1, ErlOpts1)
  +              ErlOpts1 = case lists:member(S, ErlFirstFiles) of
  +                             true -> ErlOptsFirst;
  +                             false -> ErlOpts
  +                         end,
  +              internal_erl_compile(C, S, OutDir1, ErlOpts1)
         end),
       true = rebar_utils:cleanup_code_path(CurrPath),
       ok.
   
  -%% Get files which need to be compiled first, i.e. those specified in erl_first_files
  -%% and parse_transform options.  Also produce specific erl_opts for these first
  -%% files, so that yet to be compiled parse transformations are excluded from it.
  +%% Get files which need to be compiled first, i.e. those specified in
  +%% erl_first_files and parse_transform options. Also produce specific
  +%% erl_opts for these first files, so that yet to be compiled parse
  +%% transformations are excluded from it.
   erl_first_files(Config, ErlOpts, NeededErlFiles) ->
       %% NOTE: rebar_config:get_local perhaps?
       ErlFirstFilesConf = rebar_config:get_list(Config, erl_first_files, []),
  -    NeededSrcDirs = lists:usort(lists:map(fun filename:dirname/1, NeededErlFiles)),
  +    NeededSrcDirs = lists:usort(
  +                      lists:map(fun filename:dirname/1, NeededErlFiles)),
       %% NOTE: order of files here is important!
       ErlFirstFiles = lists:filter(
  -        fun(File) -> lists:member(File, NeededErlFiles) end, ErlFirstFilesConf),
  -    {ParseTransforms, ParseTransformsErls} = lists:unzip(lists:flatmap(
  -        fun(PT) ->
  -            PTerls = [filename:join(Dir, module_to_erl(PT)) || Dir <- NeededSrcDirs],
  -            [{PT, PTerl} || PTerl <- PTerls, lists:member(PTerl, NeededErlFiles)]
  -        end,
  -        proplists:get_all_values(parse_transform, ErlOpts))),
  -    ErlOptsFirst = lists:filter(fun
  -        ({parse_transform, PT}) -> not lists:member(PT, ParseTransforms);
  -        (_) -> true
  -    end, ErlOpts),
  +                      fun(File) -> lists:member(File, NeededErlFiles) end,
  +                      ErlFirstFilesConf),
  +    {ParseTransforms, ParseTransformsErls} =
  +        lists:unzip(
  +          lists:flatmap(
  +            fun(PT) ->
  +                    PTerls = [filename:join(Dir, module_to_erl(PT))
  +                              || Dir <- NeededSrcDirs],
  +                    [{PT, PTerl} || PTerl <- PTerls,
  +                                    lists:member(PTerl, NeededErlFiles)]
  +            end,
  +            proplists:get_all_values(parse_transform, ErlOpts))),
  +    ErlOptsFirst = lists:filter(
  +                     fun ({parse_transform, PT}) ->
  +                             not lists:member(PT, ParseTransforms);
  +                         (_) -> true
  +                     end,
  +                     ErlOpts),
       {ErlFirstFiles ++ ParseTransformsErls, ErlOptsFirst}.
   
   %% Get subset of SourceFiles which need to be recompiled, respecting
   %% dependencies induced by given graph G.
   needed_files(G, OutDir, SourceFiles) ->
  -    lists:filter(fun(Source) ->
  -        Target = target_base(OutDir, Source) ++ ".beam",
  -        digraph:vertex(G, Source) > {Source, filelib:last_modified(Target)}
  -    end, SourceFiles).
  +    lists:filter(
  +      fun(Source) ->
  +              Target = target_base(OutDir, Source) ++ ".beam",
  +              digraph:vertex(G, Source) >
  +                  {Source, filelib:last_modified(Target)}
  +      end, SourceFiles).
   
   target_base(OutDir, Source) ->
       filename:join(OutDir, filename:basename(Source, ".erl")).
  
positive.code: erlcinfo_file() ->
      filename:join([rebar_utils:get_cwd(), ".rebar", ?ERLCINFO_FILE]).
  
  %% Get dependency graph of given Erls files and their dependencies (header files,
  %% parse transforms, behaviours etc.) located in their directories or given
  %% InclDirs.  Note that last modification times stored in vertices already respect
  %% dependencies induced by given graph G.
  init_erlcinfo(InclDirs, Erls) ->
      G = digraph:new([acyclic]),
      try restore_erlcinfo(G, InclDirs)
      catch
          _:_ ->
              ?WARN("Failed to restore ~s file. Discarding it.~n", [erlcinfo_file()]),
              ok = file:delete(erlcinfo_file())
      end,
      Dirs = source_and_include_dirs(InclDirs, Erls),
  
negative.code: 
      G = init_erlcinfo(proplists:get_all_values(i, ErlOpts), AllErlFiles),
      NeededErlFiles = needed_files(G, OutDir1, AllErlFiles),
      {ErlFirstFiles, ErlOptsFirst} = erl_first_files(Config,
                                                      ErlOpts,
                                                      NeededErlFiles),
      {DepErls, OtherErls} =
          lists:partition(
            fun(Source) ->
                    digraph:in_degree(G, Source) > 0
            end,
            [F || F <- NeededErlFiles, not lists:member(F, ErlFirstFiles)]),
      DepErlsOrdered = digraph_utils:topsort(digraph_utils:subgraph(G, DepErls)),
      FirstErls = ErlFirstFiles ++ lists:reverse(DepErlsOrdered),
      ?DEBUG("Files to compile first: ~p~n", [FirstErls]),
  