Merge pull request #828 from project-fifo/nice-dialyzer

Group dialyzer warnings by file and concentrate output

2 files changed, 128 insertions, 107 deletions

diff --git a/src/rebar_dialyzer_format.erl b/src/rebar_dialyzer_format.erl
index 0fd2b6e..b30c4dc 100644
--- a/src/rebar_dialyzer_format.erl
+++ b/src/rebar_dialyzer_format.erl
@@ -1,42 +1,67 @@
+%%%
+%%% General colour conventions mostly follow the same schema
+%%% that git uses:
+%%%
+%%% * cyan:  files/lines or locations in general
+%%% * bold:  important text i.e. the human parts of warnings
+%%%          this allows quickly 'scanning' over a warning fading
+%%%          out the cody bits
+%%% * red:   things that went bad, i.e. the wrong argument in a
+%%%          call. It allows to quickly catching where in the code
+%%%          ane error is.
+%%% * green: the 'good' stuff, i.e. what was expected as an argument
+%%%          the 'red vs green' resambles the diff view 'remove vs add'
+%%% * blue:  argument positions.
 -module(rebar_dialyzer_format).
 
 -include("rebar.hrl").
 
--export([format/1]).
-
-
-format(Warning) ->
-    Str = try
-              format_warning(Warning, fullpath)
-          catch
-              Error:Reason ->
-                  ?DEBUG("Failed to pretty format warning: ~p:~p",
-                         [Error, Reason]),
-                  dialyzer:format_warning(Warning, fullpath)
-          end,
-    case strip(Str) of
-        ":0: " ++ Unknown ->
-            Unknown;
-        Warning1 ->
-            Warning1
-    end.
+-export([format_warnings/1]).
+
+%% Formats a list of warnings in a nice per file way. Note that we reverse
+%% the list at the end to 'undo' the reversal by foldl
+format_warnings(Warnings) ->
+    {_, Res} = lists:foldl(fun format_warning_/2, {undefined, []}, Warnings),
+    lists:reverse(Res).
+
+
+%% If the last seen file is and the file of this warning are the same
+%% we skip the file header
+format_warning_(Warning = {_Tag, {File, Line}, Msg}, {File, Acc}) ->
+    try
+        String = message_to_string(Msg),
+        {File, [lists:flatten(fmt("~!c~4w~!!: ~s", [Line, String])) | Acc]}
+    catch
+        Error:Reason ->
+            ?DEBUG("Failed to pretty format warning: ~p:~p",
+                   [Error, Reason]),
+            {File, [dialyzer:format_warning(Warning, fullpath) | Acc]}
+    end;
 
-strip(Warning) ->
-    string:strip(Warning, right, $\n).
+%% With a new file detencted we also write a file header.
+format_warning_(Warning = {_Tag, {File, Line}, Msg}, {_LastFile, Acc}) ->
+    try
+        Base = filename:basename(File),
+        Dir = filename:dirname(File),
+        Root = filename:rootname(Base),
+        Ext = filename:extension(Base),
+        Path = re:replace(Dir, "^.*/_build/", "_build/", [{return, list}]),
+        Base1 = fmt("~!_c~s~!!~!__~s", [Root, Ext]),
+        F = fmt("~!__~s", [filename:join(Path, Base1)]),
+        String = message_to_string(Msg),
+        {File, [lists:flatten(fmt("~n~s~n~!c~4w~!!: ~s", [F, Line, String])) | Acc]}
+    catch
+        Error:Reason ->
+            ?DEBUG("Failed to pretty format warning: ~p:~p~n~p",
+                   [Error, Reason, erlang:get_stacktrace()]),
+            {File, [dialyzer:format_warning(Warning, fullpath) | Acc]}
+    end.
 
 fmt(Fmt) ->
     cf:format(Fmt, []).
 fmt(Fmt, Args) ->
     cf:format(Fmt, Args).
 
-format_warning({Tag, {File, Line, _MFA}, Msg}, FOpt) ->
-    format_warning({Tag, {File, Line}, Msg}, FOpt);
-format_warning({_Tag, {File, Line}, Msg}, fullpath) when is_list(File),
-                                                       is_integer(Line) ->
-    F = re:replace(File, "^.*/_build/", "_build/"),
-    String = lists:flatten(message_to_string(Msg)),
-    lists:flatten(fmt("~s:~w~n~s", [F, Line, String])).
-
 %%-----------------------------------------------------------------------------
 %% Message classification and pretty-printing below. Messages appear in
 %% categories and in more or less alphabetical ordering within each category.
@@ -50,49 +75,48 @@ message_to_string({apply, [Args, ArgNs, FailReason,
         call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
 message_to_string({app_call, [M, F, Args, Culprit, ExpectedType, FoundType]}) ->
     fmt("~!^The call~!! ~s:~s~s ~!^requires that"
-        "~!! ~s ~!^is of type ~!g~s~!^ not ~!r~s"
-        "~!!\n",
+        "~!! ~s ~!^is of type ~!g~s~!^ not ~!r~s",
         [M, F, Args, Culprit, ExpectedType, FoundType]);
 message_to_string({bin_construction, [Culprit, Size, Seg, Type]}) ->
     fmt("~!^Binary construction will fail since the ~!b~s~!^ field~!!"
-        " ~s~!^ in segment~!! ~s~!^ has type~!! ~s\n",
+        " ~s~!^ in segment~!! ~s~!^ has type~!! ~s",
         [Culprit, Size, Seg, Type]);
 message_to_string({call, [M, F, Args, ArgNs, FailReason,
                           SigArgs, SigRet, Contract]}) ->
     fmt("~!^The call~!! ~w:~w~s ", [M, F, bad_arg(ArgNs, Args)]) ++
         call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
 message_to_string({call_to_missing, [M, F, A]}) ->
-    fmt("~!^Call to missing or unexported function ~!!~w:~w/~w\n",
+    fmt("~!^Call to missing or unexported function ~!!~w:~w/~w",
         [M, F, A]);
 message_to_string({exact_eq, [Type1, Op, Type2]}) ->
-    fmt("~!^The test ~!!~s ~s ~s~!^ can never evaluate to 'true'\n",
+    fmt("~!^The test ~!!~s ~s ~s~!^ can never evaluate to 'true'",
         [Type1, Op, Type2]);
 message_to_string({fun_app_args, [Args, Type]}) ->
     fmt("~!^Fun application with arguments ~!!~s~!^ will fail"
-        " since the function has type ~!!~s\n", [Args, Type]);
+        " since the function has type ~!!~s", [Args, Type]);
 message_to_string({fun_app_no_fun, [Op, Type, Arity]}) ->
     fmt("~!^Fun application will fail since ~!!~s ~!^::~!! ~s"
-        " is not a function of arity ~!!~w\n", [Op, Type, Arity]);
+        " is not a function of arity ~!!~w", [Op, Type, Arity]);
 message_to_string({guard_fail, []}) ->
-    "~!^Clause guard cannot succeed.\n~!!";
+    "~!^Clause guard cannot succeed.~!!";
 message_to_string({guard_fail, [Arg1, Infix, Arg2]}) ->
-    fmt("~!^Guard test ~!!~s ~s ~s~!^ can never succeed\n",
+    fmt("~!^Guard test ~!!~s ~s ~s~!^ can never succeed",
         [Arg1, Infix, Arg2]);
 message_to_string({neg_guard_fail, [Arg1, Infix, Arg2]}) ->
-    fmt("~!^Guard test not(~!!~s ~s ~s~!^) can never succeed\n",
+    fmt("~!^Guard test not(~!!~s ~s ~s~!^) can never succeed",
         [Arg1, Infix, Arg2]);
 message_to_string({guard_fail, [Guard, Args]}) ->
-    fmt("~!^Guard test ~!!~w~s~!^ can never succeed\n",
+    fmt("~!^Guard test ~!!~w~s~!^ can never succeed",
         [Guard, Args]);
 message_to_string({neg_guard_fail, [Guard, Args]}) ->
-    fmt("~!^Guard test not(~!!~w~s~!^) can never succeed\n",
+    fmt("~!^Guard test not(~!!~w~s~!^) can never succeed",
         [Guard, Args]);
 message_to_string({guard_fail_pat, [Pat, Type]}) ->
     fmt("~!^Clause guard cannot succeed. The ~!!~s~!^ was matched"
-        " against the type ~!!~s\n", [Pat, Type]);
+        " against the type ~!!~s", [Pat, Type]);
 message_to_string({improper_list_constr, [TlType]}) ->
     fmt("~!^Cons will produce an improper list"
-        " since its ~!b2~!!nd~!^ argument is~!! ~s\n", [TlType]);
+        " since its ~!b2~!!nd~!^ argument is~!! ~s", [TlType]);
 message_to_string({no_return, [Type|Name]}) ->
     NameString =
         case Name of
@@ -100,133 +124,133 @@ message_to_string({no_return, [Type|Name]}) ->
             [F, A] -> fmt("~!^Function ~!r~w/~w ", [F, A])
         end,
     case Type of
-        no_match -> fmt("~s~!^has no clauses that will ever match\n",[NameString]);
-        only_explicit -> fmt("~s~!^only terminates with explicit exception\n", [NameString]);
-        only_normal -> fmt("~s~!^has no local return\n", [NameString]);
-        both -> fmt("~s~!^has no local return\n", [NameString])
+        no_match -> fmt("~s~!^has no clauses that will ever match",[NameString]);
+        only_explicit -> fmt("~s~!^only terminates with explicit exception", [NameString]);
+        only_normal -> fmt("~s~!^has no local return", [NameString]);
+        both -> fmt("~s~!^has no local return", [NameString])
     end;
 message_to_string({record_constr, [RecConstr, FieldDiffs]}) ->
     fmt("~!^Record construction ~!!~s~!^ violates the"
-        " declared type of field ~!!~s\n", [RecConstr, FieldDiffs]);
+        " declared type of field ~!!~s", [RecConstr, FieldDiffs]);
 message_to_string({record_constr, [Name, Field, Type]}) ->
     fmt("~!^Record construction violates the declared type for ~!!#~w{}~!^"
-        " since ~!!~s~!^ cannot be of type ~!!~s\n",
+        " since ~!!~s~!^ cannot be of type ~!!~s",
         [Name, Field, Type]);
 message_to_string({record_matching, [String, Name]}) ->
     fmt("~!^The ~!!~s~!^ violates the"
-        " declared type for ~!!#~w{}\n", [String, Name]);
+        " declared type for ~!!#~w{}", [String, Name]);
 message_to_string({record_match, [Pat, Type]}) ->
     fmt("~!^Matching of ~!!~s~!^ tagged with a record name violates the"
-        " declared type of ~!!~s\n", [Pat, Type]);
+        " declared type of ~!!~s", [Pat, Type]);
 message_to_string({pattern_match, [Pat, Type]}) ->
-    fmt("~!^The ~s~!^ can never match the type ~!g~s\n",
+    fmt("~!^The ~s~!^ can never match the type ~!g~s",
         [bad_pat(Pat), Type]);
 message_to_string({pattern_match_cov, [Pat, Type]}) ->
     fmt("~!^The ~s~!^ can never match since previous"
-        " clauses completely covered the type ~!g~s\n",
+        " clauses completely covered the type ~!g~s",
         [bad_pat(Pat), Type]);
 message_to_string({unmatched_return, [Type]}) ->
     fmt("~!^Expression produces a value of type ~!!~s~!^,"
-        " but this value is unmatched\n", [Type]);
+        " but this value is unmatched", [Type]);
 message_to_string({unused_fun, [F, A]}) ->
-    fmt("~!^Function ~!r~w/~w~!^ will never be called\n", [F, A]);
+    fmt("~!^Function ~!r~w/~w~!!~!^ will never be called", [F, A]);
 %%----- Warnings for specs and contracts -------------------
 message_to_string({contract_diff, [M, F, _A, Contract, Sig]}) ->
     fmt("~!^Type specification ~!!~w:~w~s~!^"
-        " is not equal to the success typing: ~!!~w:~w~s\n",
+        " is not equal to the success typing: ~!!~w:~w~s",
         [M, F, Contract, M, F, Sig]);
 message_to_string({contract_subtype, [M, F, _A, Contract, Sig]}) ->
     fmt("~!^Type specification ~!!~w:~w~s~!^"
-        " is a subtype of the success typing: ~!!~w:~w~s\n",
+        " is a subtype of the success typing: ~!!~w:~w~s",
         [M, F, Contract, M, F, Sig]);
 message_to_string({contract_supertype, [M, F, _A, Contract, Sig]}) ->
     fmt("~!^Type specification ~!!~w:~w~s~!^"
-        " is a supertype of the success typing: ~!!~w:~w~s\n",
+        " is a supertype of the success typing: ~!!~w:~w~s",
         [M, F, Contract, M, F, Sig]);
 message_to_string({contract_range, [Contract, M, F, ArgStrings, Line, CRet]}) ->
     fmt("~!^The contract ~!!~w:~w~s~!^ cannot be right because the"
-        " inferred return for ~!!~w~s~!^ on line ~!!~w~!^ is ~!!~s\n",
+        " inferred return for ~!!~w~s~!^ on line ~!!~w~!^ is ~!!~s",
         [M, F, Contract, F, ArgStrings, Line, CRet]);
 message_to_string({invalid_contract, [M, F, A, Sig]}) ->
     fmt("~!^Invalid type specification for function~!! ~w:~w/~w."
-        "~!^ The success typing is~!! ~s\n", [M, F, A, Sig]);
+        "~!^ The success typing is~!! ~s", [M, F, A, Sig]);
 message_to_string({extra_range, [M, F, A, ExtraRanges, SigRange]}) ->
     fmt("~!^The specification for ~!!~w:~w/~w~!^ states that the function"
-        " might also return ~!!~s~!^ but the inferred return is ~!!~s\n",
+        " might also return ~!!~s~!^ but the inferred return is ~!!~s",
         [M, F, A, ExtraRanges, SigRange]);
 message_to_string({overlapping_contract, [M, F, A]}) ->
     fmt("~!^Overloaded contract for ~!!~w:~w/~w~!^ has overlapping"
         " domains; such contracts are currently unsupported and are simply "
-        "ignored\n", [M, F, A]);
+        "ignored", [M, F, A]);
 message_to_string({spec_missing_fun, [M, F, A]}) ->
-    fmt("~!^Contract for function that does not exist: ~!!~w:~w/~w\n",
+    fmt("~!^Contract for function that does not exist: ~!!~w:~w/~w",
         [M, F, A]);
 %%----- Warnings for opaque type violations -------------------
 message_to_string({call_with_opaque, [M, F, Args, ArgNs, ExpArgs]}) ->
-    fmt("~!^The call ~!!~w:~w~s~!^ contains ~!!~s~!^ when ~!!~s\n",
-        [M, F, Args, form_positions(ArgNs), form_expected(ExpArgs)]);
+    fmt("~!^The call ~!!~w:~w~s~!^ contains ~!!~s~!^ when ~!!~s",
+        [M, F, bad_arg(ArgNs, Args), form_positions(ArgNs), form_expected(ExpArgs)]);
 message_to_string({call_without_opaque, [M, F, Args, [{N,_,_}|_] = ExpectedTriples]}) ->
-    fmt("~!^The call ~!!~w:~w~s ~!^does not have~!! ~s\n",
+    fmt("~!^The call ~!!~w:~w~s ~!^does not have~!! ~s",
         [M, F, bad_arg(N, Args), form_expected_without_opaque(ExpectedTriples)]);
 message_to_string({opaque_eq, [Type, _Op, OpaqueType]}) ->
     fmt("~!^Attempt to test for equality between a term of type ~!!~s~!^"
-        " and a term of opaque type ~!!~s\n", [Type, OpaqueType]);
+        " and a term of opaque type ~!!~s", [Type, OpaqueType]);
 message_to_string({opaque_guard, [Arg1, Infix, Arg2, ArgNs]}) ->
-    fmt("~!^Guard test ~!!~s ~s ~s~!^ contains ~!!~s\n",
+    fmt("~!^Guard test ~!!~s ~s ~s~!^ contains ~!!~s",
         [Arg1, Infix, Arg2, form_positions(ArgNs)]);
 message_to_string({opaque_guard, [Guard, Args]}) ->
     fmt("~!^Guard test ~!!~w~s~!^ breaks the opaqueness of its"
-        " argument\n", [Guard, Args]);
+        " argument", [Guard, Args]);
 message_to_string({opaque_match, [Pat, OpaqueType, OpaqueTerm]}) ->
     Term = if OpaqueType =:= OpaqueTerm -> "the term";
               true -> OpaqueTerm
            end,
     fmt("~!^The attempt to match a term of type ~!!~s~!^ against the"
-        "~!! ~s~!^ breaks the opaqueness of ~!!~s\n",
+        "~!! ~s~!^ breaks the opaqueness of ~!!~s",
         [OpaqueType, Pat, Term]);
 message_to_string({opaque_neq, [Type, _Op, OpaqueType]}) ->
     fmt("~!^Attempt to test for inequality between a term of type ~!!~s"
-        "~!^ and a term of opaque type ~!!~s\n", [Type, OpaqueType]);
+        "~!^ and a term of opaque type ~!!~s", [Type, OpaqueType]);
 message_to_string({opaque_type_test, [Fun, Args, Arg, ArgType]}) ->
     fmt("~!^The type test ~!!~s~s~!^ breaks the opaqueness of the term "
-        "~!!~s~s\n", [Fun, Args, Arg, ArgType]);
+        "~!!~s~s", [Fun, Args, Arg, ArgType]);
 message_to_string({opaque_size, [SizeType, Size]}) ->
-    fmt("~!^The size ~!!~s~!^ breaks the opaqueness of ~!!~s\n",
+    fmt("~!^The size ~!!~s~!^ breaks the opaqueness of ~!!~s",
         [SizeType, Size]);
 message_to_string({opaque_call, [M, F, Args, Culprit, OpaqueType]}) ->
     fmt("~!^The call ~!!~s:~s~s~!^ breaks the opaqueness of the term~!!"
-        " ~s :: ~s\n", [M, F, Args, Culprit, OpaqueType]);
+        " ~s :: ~s", [M, F, Args, Culprit, OpaqueType]);
 %%----- Warnings for concurrency errors --------------------
 message_to_string({race_condition, [M, F, Args, Reason]}) ->
-    fmt("~!^The call ~!!~w:~w~s ~s\n", [M, F, Args, Reason]);
+    fmt("~!^The call ~!!~w:~w~s ~s", [M, F, Args, Reason]);
 %%----- Warnings for behaviour errors --------------------
 message_to_string({callback_type_mismatch, [B, F, A, ST, CT]}) ->
     fmt("~!^The inferred return type of~!! ~w/~w (~s) ~!^"
         "has nothing in common with~!! ~s, ~!^which is the expected"
-        " return type for the callback of~!! ~w ~!^behaviour\n",
+        " return type for the callback of~!! ~w ~!^behaviour",
         [F, A, ST, CT, B]);
 message_to_string({callback_arg_type_mismatch, [B, F, A, N, ST, CT]}) ->
     fmt("~!^The inferred type for the~!! ~s ~!^argument of~!!"
         " ~w/~w (~s) ~!^is not a supertype of~!! ~s~!^, which is"
         "expected type for this argument in the callback of the~!! ~w "
-        "~!^behaviour\n",
+        "~!^behaviour",
         [ordinal(N), F, A, ST, CT, B]);
 message_to_string({callback_spec_type_mismatch, [B, F, A, ST, CT]}) ->
     fmt("~!^The return type ~!!~s~!^ in the specification of ~!!"
         "~w/~w~!^ is not a subtype of ~!!~s~!^, which is the expected"
-        " return type for the callback of ~!!~w~!^ behaviour\n",
+        " return type for the callback of ~!!~w~!^ behaviour",
         [ST, F, A, CT, B]);
 message_to_string({callback_spec_arg_type_mismatch, [B, F, A, N, ST, CT]}) ->
     fmt("~!^The specified type for the ~!!~s~!^ argument of ~!!"
         "~w/~w (~s)~!^ is not a supertype of ~!!~s~!^, which is"
         " expected type for this argument in the callback of the ~!!~w"
-        "~!^ behaviour\n", [ordinal(N), F, A, ST, CT, B]);
+        "~!^ behaviour", [ordinal(N), F, A, ST, CT, B]);
 message_to_string({callback_missing, [B, F, A]}) ->
     fmt("~!^Undefined callback function ~!!~w/~w~!^ (behaviour ~!!"
-        "'~w'~!^)\n",[F, A, B]);
+        "'~w'~!^)",[F, A, B]);
 message_to_string({callback_info_missing, [B]}) ->
-    fmt("~!^Callback info about the ~!r~w~!^"
-        " behaviour is not available\n", [B]);
+    fmt("~!^Callback info about the ~!r~w~!!~!^"
+        " behaviour is not available", [B]);
 %%----- Warnings for unknown functions, types, and behaviours -------------
 message_to_string({unknown_type, {M, F, A}}) ->
     fmt("~!^Unknown type ~!r~w:~w/~w", [M, F, A]);
@@ -248,39 +272,36 @@ call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet,
                 true ->
                     %% We do not know which argument(s) caused the failure
                     fmt("~!^will never return since the success typing arguments"
-                        " are ~!!~s\n", [SigArgs]);
+                        " are ~!!~s", [SigArgs]);
                 false ->
                     fmt("~!^will never return since it differs in the~!!"
                         " ~s ~!^argument from the success typing"
-                        " arguments:~!! ~s\n",
+                        " arguments:~!! ~s",
                         [PositionString, good_arg(ArgNs, SigArgs)])
             end;
         only_contract ->
             case (ArgNs =:= []) orelse IsOverloaded of
                 true ->
                     %% We do not know which arguments caused the failure
-                    fmt("~!^breaks the contract~!! ~s\n", [good_arg(ArgNs, Contract)]);
+                    fmt("~!^breaks the contract~!! ~s", [good_arg(ArgNs, Contract)]);
                 false ->
                     fmt("~!^breaks the contract~!! ~s ~!^in the~!!"
-                        " ~s ~!^argument\n",
+                        " ~s ~!^argument",
                         [good_arg(ArgNs, Contract), PositionString])
             end;
         both ->
             fmt("~!^will never return since the success typing is "
-                "~!!~s ~!^->~!! ~s ~!^and the contract is ~!!~s\n",
+                "~!!~s ~!^->~!! ~s ~!^and the contract is ~!!~s",
                 [good_arg(ArgNs, SigArgs), SigRet,
                  good_arg(ArgNs, Contract)])
     end.
 
 form_positions(ArgNs) ->
+    ArgS = form_position_string(ArgNs),
     case ArgNs of
-        [_] -> "an opaque term as ";
-        [_,_|_] -> "opaque terms as "
-    end ++ form_position_string(ArgNs) ++
-        case ArgNs of
-            [_] -> " argument";
-            [_,_|_] -> " arguments"
-        end.
+        [_] ->     fmt("~!^an opaque term as ~!!~s~!^ argument", [ArgS]);
+        [_,_|_] -> fmt("~!^opaque terms as ~!!~s~!^ arguments", [ArgS])
+    end.
 
 %% We know which positions N are to blame;
 %% the list of triples will never be empty.
@@ -327,7 +348,7 @@ ordinal(2) -> fmt("~!B2~!!nd");
 ordinal(3) -> fmt("~!B3~!!rd");
 ordinal(N) when is_integer(N) -> fmt("~!B~w~!!th", [N]).
 
-
+%% Format a pattern ad highlight errorous part in red.
 bad_pat("pattern " ++ P) ->
     fmt("pattern ~!r~s",[P]);
 bad_pat("variable " ++ P) ->
@@ -337,14 +358,16 @@ bad_pat(P) ->
 
 
 bad_arg(N, Args) ->
-    color_arg(N, r, Args).
+    colour_arg(N, r, Args).
 
 good_arg(N, Args) ->
-    color_arg(N, g, Args).
+    colour_arg(N, g, Args).
 
-color_arg(N, C, Args) when is_integer(N) ->
-    color_arg([N], C, Args);
-color_arg(Ns, C, Args) ->
+%% colour one or more arg of an argument list, this unparses the args
+%% highlights one or more of them and puts them back together.
+colour_arg(N, C, Args) when is_integer(N) ->
+    colour_arg([N], C, Args);
+colour_arg(Ns, C, Args) ->
     {Args1, Rest} =seperate_args(Args),
     Args2 = highlight(Ns, 1, C, Args1),
     join_args(Args2) ++ Rest.
@@ -361,11 +384,13 @@ highlight([N | Nr], N, r, [Arg | Rest]) ->
 highlight(Ns, N, C, [Arg | Rest]) ->
     [Arg | highlight(Ns, N + 1, C, Rest)].
 
+%% Arugments to functions and constraints are passed as
+%% strings not as data, this function pulls them apart
+%% to allow interacting with them seperately and not
+%% as one bug chunk of data.
 seperate_args([$( | S]) ->
     seperate_args([], S, "", []).
 
-
-
 %% We strip this space since dialyzer is inconsistant in adding or not adding
 %% it ....
 seperate_args([], [$,, $\s | R], Arg, Args) ->
diff --git a/src/rebar_prv_dialyzer.erl b/src/rebar_prv_dialyzer.erl
index 7cf7e28..487e9d1 100644
--- a/src/rebar_prv_dialyzer.erl
+++ b/src/rebar_prv_dialyzer.erl
@@ -402,14 +402,10 @@ run_dialyzer(State, Opts, Output) ->
     end.
 
 format_warnings(Output, Warnings) ->
-    Warnings1 = format_warnings(Warnings),
+    Warnings1 = rebar_dialyzer_format:format_warnings(Warnings),
     console_warnings(Warnings1),
     file_warnings(Output, Warnings),
-    length(Warnings1).
-
-format_warnings(Warnings) ->
-    [rebar_dialyzer_format:format(Warning) || Warning <- Warnings].
-
+    length(Warnings).
 
 console_warnings(Warnings) ->
     _ = [?CONSOLE("~s", [Warning]) || Warning <- Warnings],