anchor.diff:                  {ActualModule, _} when is_list(ActualModule) ->
                       ActualModuleStr = string:join([atom_to_list(P) || P <- ActualModule], ".")
               end,
  -            inspect_epp(Epp, ActualModuleStr, Includes);
  +            inspect_epp(Epp, Source, ActualModuleStr, Includes);
           {ok, {attribute, 1, file, {Module, 1}}} ->
  -            inspect_epp(Epp, Module, Includes);
  +            inspect_epp(Epp, Source, Module, Includes);
  +        {ok, {attribute, 1, file, {Source, 1}}} ->
  +            inspect_epp(Epp, Source, Module, Includes);
           {ok, {attribute, 1, file, {IncFile, 1}}} ->
  -            inspect_epp(Epp, Module, [IncFile | Includes]);
  +            inspect_epp(Epp, Source, Module, [IncFile | Includes]);
           {eof, _} ->
               epp:close(Epp),
               {Module, Includes};
           _ ->
  -            inspect_epp(Epp, Module, Includes)
  +            inspect_epp(Epp, Source, Module, Includes)
       end.
   
   -spec needs_compile(Source::string(), Target::string(), Hrls::[string()]) -> boolean().
  
positive.code:     RestErls  = [Source || Source <- gather_src(SrcDirs, []) ++ MoreSources,
                             lists:member(Source, FirstErls) == false],
  
      %% Make sure that ebin/ is on the path
      CurrPath = code:get_path(),
      code:add_path("ebin"),
      rebar_base_compiler:run(Config, FirstErls, RestErls,
                              fun(S, C) -> internal_erl_compile(S, C, OutDir) end),
      code:set_path(CurrPath),
      ok.
  
negative.code: delete_dir(Dir, Subdirs) ->
      lists:foreach(fun(D) -> delete_dir(D, dirs(D)) end, Subdirs),
      file:del_dir(Dir).
  
  -spec compile_priority(File::string()) -> pos_integer().
  compile_priority(File) ->
      case epp_dodger:parse_file(File) of
          {error, _} ->
              10; % couldn't parse the file, default priority
          {ok, Trees} ->
              ?DEBUG("Computing priority of ~p\n", [File]),
              F2 = fun({tree,arity_qualifier,_,
                          {arity_qualifier,{tree,atom,_,behaviour_info},
                              {tree,integer,_,1}}}, _) ->
                      2;
                  ({tree,arity_qualifier,_,
                          {arity_qualifier,{tree,atom,_,parse_transform},
                              {tree,integer,_,2}}}, _) ->
                      1;
                  (_, Acc) ->
                      Acc
              end,
  
              F = fun({tree, attribute, _, {attribute, {tree, atom, _, export},
                              [{tree, list, _, {list, List, none}}]}}, Acc) ->
                      lists:foldl(F2, Acc, List);
                  (_, Acc) ->
                      Acc
              end,
  
              lists:foldl(F, 10, Trees)
      end.
  