|
|
|
@ -31,7 +31,7 @@ format_warnings(Opts, Warnings) -> |
|
|
|
format_warning_(_Opts, Warning = {_Tag, {File, Line}, Msg}, {File, Acc}) -> |
|
|
|
try |
|
|
|
String = message_to_string(Msg), |
|
|
|
{File, [lists:flatten(fmt("~!c~4w~!!:
~s", [Line, String])) | Acc]} |
|
|
|
{File, [lists:flatten(fmt("~!c~4w~!!: ~ts", [Line, String])) | Acc]} |
|
|
|
catch |
|
|
|
Error:Reason -> |
|
|
|
?DEBUG("Failed to pretty format warning: ~p:~p", |
|
|
|
@ -47,11 +47,11 @@ format_warning_(Opts, Warning = {_Tag, {SrcFile, Line}, Msg}, {_LastFile, Acc}) |
|
|
|
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)]), |
|
|
|
Path = re:replace(Dir, "^.*/_build/", "_build/", [{return, list}, unicode]), |
|
|
|
Base1 = fmt("~!_c~ts~!!~!__~ts", [Root, Ext]), |
|
|
|
F = fmt("~!__~ts", [filename:join(Path, Base1)]), |
|
|
|
String = message_to_string(Msg), |
|
|
|
{SrcFile, [lists:flatten(fmt("~n
~s~n~!c~4w~!!:
~s", [F, Line, String])) | Acc]} |
|
|
|
{SrcFile, [lists:flatten(fmt("~n~ts~n~!c~4w~!!: ~ts", [F, Line, String])) | Acc]} |
|
|
|
catch |
|
|
|
Error:Reason -> |
|
|
|
?DEBUG("Failed to pretty format warning: ~p:~p~n~p", |
|
|
|
@ -72,53 +72,53 @@ fmt(Fmt, Args) -> |
|
|
|
%%----- Warnings for general discrepancies ---------------- |
|
|
|
message_to_string({apply, [Args, ArgNs, FailReason, |
|
|
|
SigArgs, SigRet, Contract]}) -> |
|
|
|
fmt("~!^Fun application with arguments ~!!
~s ", |
|
|
|
fmt("~!^Fun application with arguments ~!!~ts ", |
|
|
|
[bad_arg(ArgNs, Args)]) ++ |
|
|
|
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", |
|
|
|
fmt("~!^The call~!! ~ts:~ts~ts ~!^requires that" |
|
|
|
"~!! ~ts ~!^is of type ~!g~ts~!^ not ~!r~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^Binary construction will fail since the ~!b~ts~!^ field~!!" |
|
|
|
" ~ts~!^ in segment~!! ~ts~!^ has type~!! ~ts", |
|
|
|
[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)]) ++ |
|
|
|
fmt("~!^The call~!! ~w:~w~ts ", [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", |
|
|
|
[M, F, A]); |
|
|
|
message_to_string({exact_eq, [Type1, Op, Type2]}) -> |
|
|
|
fmt("~!^The test ~!!
~s
~s
~s~!^ can never evaluate to 'true'", |
|
|
|
fmt("~!^The test ~!!~ts ~ts ~ts~!^ 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", [Args, Type]); |
|
|
|
fmt("~!^Fun application with arguments ~!!~ts~!^ will fail" |
|
|
|
" since the function has type ~!!~ts", [Args, Type]); |
|
|
|
message_to_string({fun_app_no_fun, [Op, Type, Arity]}) -> |
|
|
|
fmt("~!^Fun application will fail since ~!!
~s ~!^::~!!
~s" |
|
|
|
fmt("~!^Fun application will fail since ~!!~ts ~!^::~!! ~ts" |
|
|
|
" is not a function of arity ~!!~w", [Op, Type, Arity]); |
|
|
|
message_to_string({guard_fail, []}) -> |
|
|
|
"~!^Clause guard cannot succeed.~!!"; |
|
|
|
message_to_string({guard_fail, [Arg1, Infix, Arg2]}) -> |
|
|
|
fmt("~!^Guard test ~!!
~s
~s
~s~!^ can never succeed", |
|
|
|
fmt("~!^Guard test ~!!~ts ~ts ~ts~!^ 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", |
|
|
|
fmt("~!^Guard test not(~!!~ts ~ts ~ts~!^) can never succeed", |
|
|
|
[Arg1, Infix, Arg2]); |
|
|
|
message_to_string({guard_fail, [Guard, Args]}) -> |
|
|
|
fmt("~!^Guard test ~!!~w
~s~!^ can never succeed", |
|
|
|
fmt("~!^Guard test ~!!~w~ts~!^ can never succeed", |
|
|
|
[Guard, Args]); |
|
|
|
message_to_string({neg_guard_fail, [Guard, Args]}) -> |
|
|
|
fmt("~!^Guard test not(~!!~w
~s~!^) can never succeed", |
|
|
|
fmt("~!^Guard test not(~!!~w~ts~!^) 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", [Pat, Type]); |
|
|
|
fmt("~!^Clause guard cannot succeed. The ~!!~ts~!^ was matched" |
|
|
|
" against the type ~!!~ts", [Pat, Type]); |
|
|
|
message_to_string({improper_list_constr, [TlType]}) -> |
|
|
|
fmt("~!^Cons will produce an improper list" |
|
|
|
" since its ~!b2~!!nd~!^ argument is~!!
~s", [TlType]); |
|
|
|
" since its ~!b2~!!nd~!^ argument is~!! ~ts", [TlType]); |
|
|
|
message_to_string({no_return, [Type|Name]}) -> |
|
|
|
NameString = |
|
|
|
case Name of |
|
|
|
@ -126,59 +126,59 @@ 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",[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]) |
|
|
|
no_match -> fmt("~ts~!^has no clauses that will ever match",[NameString]); |
|
|
|
only_explicit -> fmt("~ts~!^only terminates with explicit exception", [NameString]); |
|
|
|
only_normal -> fmt("~ts~!^has no local return", [NameString]); |
|
|
|
both -> fmt("~ts~!^has no local return", [NameString]) |
|
|
|
end; |
|
|
|
message_to_string({record_constr, [RecConstr, FieldDiffs]}) -> |
|
|
|
fmt("~!^Record construction ~!!
~s~!^ violates the" |
|
|
|
" declared type of field ~!!
~s", [RecConstr, FieldDiffs]); |
|
|
|
fmt("~!^Record construction ~!!~ts~!^ violates the" |
|
|
|
" declared type of field ~!!~ts", [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", |
|
|
|
" since ~!!~ts~!^ cannot be of type ~!!~ts", |
|
|
|
[Name, Field, Type]); |
|
|
|
message_to_string({record_matching, [String, Name]}) -> |
|
|
|
fmt("~!^The ~!!
~s~!^ violates the" |
|
|
|
fmt("~!^The ~!!~ts~!^ violates the" |
|
|
|
" 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", [Pat, Type]); |
|
|
|
fmt("~!^Matching of ~!!~ts~!^ tagged with a record name violates the" |
|
|
|
" declared type of ~!!~ts", [Pat, Type]); |
|
|
|
message_to_string({pattern_match, [Pat, Type]}) -> |
|
|
|
fmt("~!^The
~s~!^ can never match the type ~!g
~s", |
|
|
|
fmt("~!^The ~ts~!^ can never match the type ~!g~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^The ~ts~!^ can never match since previous" |
|
|
|
" clauses completely covered the type ~!g~ts", |
|
|
|
[bad_pat(Pat), Type]); |
|
|
|
message_to_string({unmatched_return, [Type]}) -> |
|
|
|
fmt("~!^Expression produces a value of type ~!!
~s~!^," |
|
|
|
fmt("~!^Expression produces a value of type ~!!~ts~!^," |
|
|
|
" but this value is unmatched", [Type]); |
|
|
|
message_to_string({unused_fun, [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", |
|
|
|
fmt("~!^Type specification ~!!~w:~w~ts~!^" |
|
|
|
" is not equal to the success typing: ~!!~w:~w~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^Type specification ~!!~w:~w~ts~!^" |
|
|
|
" is a subtype of the success typing: ~!!~w:~w~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^Type specification ~!!~w:~w~ts~!^" |
|
|
|
" is a supertype of the success typing: ~!!~w:~w~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^The contract ~!!~w:~w~ts~!^ cannot be right because the" |
|
|
|
" inferred return for ~!!~w~ts~!^ on line ~!!~w~!^ is ~!!~ts", |
|
|
|
[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", [M, F, A, Sig]); |
|
|
|
"~!^ The success typing is~!! ~ts", [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", |
|
|
|
" might also return ~!!~ts~!^ but the inferred return is ~!!~ts", |
|
|
|
[M, F, A, ExtraRanges, SigRange]); |
|
|
|
message_to_string({overlapping_contract, [M, F, A]}) -> |
|
|
|
fmt("~!^Overloaded contract for ~!!~w:~w/~w~!^ has overlapping" |
|
|
|
@ -189,62 +189,62 @@ message_to_string({spec_missing_fun, [M, F, A]}) -> |
|
|
|
[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", |
|
|
|
fmt("~!^The call ~!!~w:~w~ts~!^ contains ~!!~ts~!^ when ~!!~ts", |
|
|
|
[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", |
|
|
|
fmt("~!^The call ~!!~w:~w~ts ~!^does not have~!! ~ts", |
|
|
|
[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", [Type, OpaqueType]); |
|
|
|
fmt("~!^Attempt to test for equality between a term of type ~!!~ts~!^" |
|
|
|
" and a term of opaque type ~!!~ts", [Type, OpaqueType]); |
|
|
|
message_to_string({opaque_guard, [Arg1, Infix, Arg2, ArgNs]}) -> |
|
|
|
fmt("~!^Guard test ~!!
~s
~s
~s~!^ contains ~!!
~s", |
|
|
|
fmt("~!^Guard test ~!!~ts ~ts ~ts~!^ contains ~!!~ts", |
|
|
|
[Arg1, Infix, Arg2, form_positions(ArgNs)]); |
|
|
|
message_to_string({opaque_guard, [Guard, Args]}) -> |
|
|
|
fmt("~!^Guard test ~!!~w
~s~!^ breaks the opaqueness of its" |
|
|
|
fmt("~!^Guard test ~!!~w~ts~!^ breaks the opaqueness of its" |
|
|
|
" 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", |
|
|
|
fmt("~!^The attempt to match a term of type ~!!~ts~!^ against the" |
|
|
|
"~!! ~ts~!^ breaks the opaqueness of ~!!~ts", |
|
|
|
[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", [Type, OpaqueType]); |
|
|
|
fmt("~!^Attempt to test for inequality between a term of type ~!!~ts" |
|
|
|
"~!^ and a term of opaque type ~!!~ts", [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", [Fun, Args, Arg, ArgType]); |
|
|
|
fmt("~!^The type test ~!!~ts~ts~!^ breaks the opaqueness of the term " |
|
|
|
"~!!~ts~ts", [Fun, Args, Arg, ArgType]); |
|
|
|
message_to_string({opaque_size, [SizeType, Size]}) -> |
|
|
|
fmt("~!^The size ~!!
~s~!^ breaks the opaqueness of ~!!
~s", |
|
|
|
fmt("~!^The size ~!!~ts~!^ breaks the opaqueness of ~!!~ts", |
|
|
|
[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", [M, F, Args, Culprit, OpaqueType]); |
|
|
|
fmt("~!^The call ~!!~ts:~ts~ts~!^ breaks the opaqueness of the term~!!" |
|
|
|
" ~ts :: ~ts", [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", [M, F, Args, Reason]); |
|
|
|
fmt("~!^The call ~!!~w:~w~ts ~ts", [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" |
|
|
|
fmt("~!^The inferred return type of~!! ~w/~w (~ts) ~!^" |
|
|
|
"has nothing in common with~!! ~ts, ~!^which is the expected" |
|
|
|
" 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" |
|
|
|
fmt("~!^The inferred type for the~!! ~ts ~!^argument of~!!" |
|
|
|
" ~w/~w (~ts) ~!^is not a supertype of~!! ~ts~!^, which is" |
|
|
|
"expected type for this argument in the callback of the~!! ~w " |
|
|
|
"~!^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" |
|
|
|
fmt("~!^The return type ~!!~ts~!^ in the specification of ~!!" |
|
|
|
"~w/~w~!^ is not a subtype of ~!!~ts~!^, which is the expected" |
|
|
|
" 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" |
|
|
|
fmt("~!^The specified type for the ~!!~ts~!^ argument of ~!!" |
|
|
|
"~w/~w (~ts)~!^ is not a supertype of ~!!~ts~!^, which is" |
|
|
|
" expected type for this argument in the callback of the ~!!~w" |
|
|
|
"~!^ behaviour", [ordinal(N), F, A, ST, CT, B]); |
|
|
|
message_to_string({callback_missing, [B, F, A]}) -> |
|
|
|
@ -274,26 +274,26 @@ 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", [SigArgs]); |
|
|
|
" are ~!!~ts", [SigArgs]); |
|
|
|
false -> |
|
|
|
fmt("~!^will never return since it differs in the~!!" |
|
|
|
"
~s ~!^argument from the success typing" |
|
|
|
" arguments:~!!
~s", |
|
|
|
" ~ts ~!^argument from the success typing" |
|
|
|
" arguments:~!! ~ts", |
|
|
|
[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", [good_arg(ArgNs, Contract)]); |
|
|
|
fmt("~!^breaks the contract~!! ~ts", [good_arg(ArgNs, Contract)]); |
|
|
|
false -> |
|
|
|
fmt("~!^breaks the contract~!!
~s ~!^in the~!!" |
|
|
|
"
~s ~!^argument", |
|
|
|
fmt("~!^breaks the contract~!! ~ts ~!^in the~!!" |
|
|
|
" ~ts ~!^argument", |
|
|
|
[good_arg(ArgNs, Contract), PositionString]) |
|
|
|
end; |
|
|
|
both -> |
|
|
|
fmt("~!^will never return since the success typing is " |
|
|
|
"~!!
~s ~!^->~!!
~s ~!^and the contract is ~!!
~s", |
|
|
|
"~!!~ts ~!^->~!! ~ts ~!^and the contract is ~!!~ts", |
|
|
|
[good_arg(ArgNs, SigArgs), SigRet, |
|
|
|
good_arg(ArgNs, Contract)]) |
|
|
|
end. |
|
|
|
@ -301,8 +301,8 @@ call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, |
|
|
|
form_positions(ArgNs) -> |
|
|
|
ArgS = form_position_string(ArgNs), |
|
|
|
case ArgNs of |
|
|
|
[_] -> fmt("~!^an opaque term as ~!!
~s~!^ argument", [ArgS]); |
|
|
|
[_,_|_] -> fmt("~!^opaque terms as ~!!
~s~!^ arguments", [ArgS]) |
|
|
|
[_] -> fmt("~!^an opaque term as ~!!~ts~!^ argument", [ArgS]); |
|
|
|
[_,_|_] -> fmt("~!^opaque terms as ~!!~ts~!^ arguments", [ArgS]) |
|
|
|
end. |
|
|
|
|
|
|
|
%% We know which positions N are to blame; |
|
|
|
@ -310,9 +310,9 @@ form_positions(ArgNs) -> |
|
|
|
form_expected_without_opaque([{N, T, TStr}]) -> |
|
|
|
FStr = case erl_types:t_is_opaque(T) of |
|
|
|
true -> |
|
|
|
"~!^an opaque term of type~!g
~s ~!^as "; |
|
|
|
"~!^an opaque term of type~!g ~ts ~!^as "; |
|
|
|
false -> |
|
|
|
"~!^a term of type ~!g
~s ~!^(with opaque subterms) as " |
|
|
|
"~!^a term of type ~!g~ts ~!^(with opaque subterms) as " |
|
|
|
end ++ form_position_string([N]) ++ "~!^ argument", |
|
|
|
fmt(FStr, [TStr]); |
|
|
|
|
|
|
|
@ -325,9 +325,9 @@ form_expected(ExpectedArgs) -> |
|
|
|
[T] -> |
|
|
|
TS = erl_types:t_to_string(T), |
|
|
|
case erl_types:t_is_opaque(T) of |
|
|
|
true -> fmt("~!^an opaque term of type ~!!
~s~!^ is" |
|
|
|
true -> fmt("~!^an opaque term of type ~!!~ts~!^ is" |
|
|
|
" expected", [TS]); |
|
|
|
false -> fmt("~!^a structured term of type ~!!
~s~!^ is" |
|
|
|
false -> fmt("~!^a structured term of type ~!!~ts~!^ is" |
|
|
|
" expected", [TS]) |
|
|
|
end; |
|
|
|
[_,_|_] -> fmt("~!^terms of different types are expected in these" |
|
|
|
@ -340,7 +340,7 @@ form_position_string(ArgNs) -> |
|
|
|
[N1] -> ordinal(N1); |
|
|
|
[_,_|_] -> |
|
|
|
[Last|Prevs] = lists:reverse(ArgNs), |
|
|
|
", " ++ Head = lists:flatten([fmt(",
~s",[ordinal(N)]) || |
|
|
|
", " ++ Head = lists:flatten([fmt(", ~ts",[ordinal(N)]) || |
|
|
|
N <- lists:reverse(Prevs)]), |
|
|
|
Head ++ " and " ++ ordinal(Last) |
|
|
|
end. |
|
|
|
@ -352,11 +352,11 @@ 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]); |
|
|
|
fmt("pattern ~!r~ts",[P]); |
|
|
|
bad_pat("variable " ++ P) -> |
|
|
|
fmt("variable ~!r
~s",[P]); |
|
|
|
fmt("variable ~!r~ts",[P]); |
|
|
|
bad_pat(P) -> |
|
|
|
fmt("~!r
~s",[P]). |
|
|
|
fmt("~!r~ts",[P]). |
|
|
|
|
|
|
|
|
|
|
|
bad_arg(N, Args) -> |
|
|
|
@ -378,10 +378,10 @@ highlight([], _N, _C, Rest) -> |
|
|
|
Rest; |
|
|
|
|
|
|
|
highlight([N | Nr], N, g, [Arg | Rest]) -> |
|
|
|
[fmt("~!g
~s", [Arg]) | highlight(Nr, N+1, g, Rest)]; |
|
|
|
[fmt("~!g~ts", [Arg]) | highlight(Nr, N+1, g, Rest)]; |
|
|
|
|
|
|
|
highlight([N | Nr], N, r, [Arg | Rest]) -> |
|
|
|
[fmt("~!r
~s", [Arg]) | highlight(Nr, N+1, r, Rest)]; |
|
|
|
[fmt("~!r~ts", [Arg]) | highlight(Nr, N+1, r, Rest)]; |
|
|
|
|
|
|
|
highlight(Ns, N, C, [Arg | Rest]) -> |
|
|
|
[Arg | highlight(Ns, N + 1, C, Rest)]. |
|
|
|
|
Fred Hebert
7 years ago
GitHub