File 1305-stdlib-Implement-error_info-for-the-io-mod... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1305-stdlib-Implement-error_info-for-the-io-module.patch of Package erlang (Revision c577547aad4fe182a4c53d158b3f41d4)

Currently displaying revision c577547aad4fe182a4c53d158b3f41d4 , Show latest

From e936b1be8bb3ff971a2b07942dea9f2e6533d2e5 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Wed, 21 Apr 2021 14:04:46 +0200
Subject: [PATCH 5/6] stdlib: Implement error_info for the io module

---
 lib/stdlib/src/erl_stdlib_errors.erl | 195 +++++++++++++++++++++++++++
 lib/stdlib/test/error_info_lib.erl   |  17 ++-
 lib/stdlib/test/io_SUITE.erl         | 110 ++++++++++++++-
 3 files changed, 318 insertions(+), 4 deletions(-)

diff --git a/lib/stdlib/src/erl_stdlib_errors.erl b/lib/stdlib/src/erl_stdlib_errors.erl
index 8eeea9ce6e..250a42a822 100644
--- a/lib/stdlib/src/erl_stdlib_errors.erl
+++ b/lib/stdlib/src/erl_stdlib_errors.erl
@@ -44,6 +44,8 @@ format_error(_Reason, [{M,F,As,Info}|_]) ->
                   format_re_error(F, As, Cause);
               unicode ->
                   format_unicode_error(F, As);
+              io ->
+                  format_io_error(F, As, Cause);
               _ ->
                   []
           end,
@@ -387,6 +389,181 @@ unicode_encoding(Enc) ->
             bad_encoding
     end.
 
+
+%% Rewrite fwrite to format and add info if call has an
+%% explicit Io Device as first argument.
+format_io_error(fwrite, Args, Cause) ->
+    format_io_error(format, Args, Cause);
+format_io_error(format = Fn, [_Io, _Fmt, _Args] = Args, Cause) ->
+    format_io_error(Fn, Args, Cause, true);
+format_io_error(put_chars = Fn, [_Io, _Chars] = Args, Cause) ->
+    format_io_error(Fn, Args, Cause, true);
+format_io_error(put_chars = Fn, [_Io, _Encoding, _Chars] = Args, Cause) ->
+    format_io_error(Fn, Args, Cause, true);
+format_io_error(nl = Fn, [_Io] = Args, Cause) ->
+    format_io_error(Fn, Args, Cause, true);
+format_io_error(write = Fn, [_Io, _Term] = Args, Cause) ->
+    format_io_error(Fn, Args, Cause, true);
+format_io_error(Fn, Args, Cause) ->
+    format_io_error(Fn, Args, Cause, false).
+
+%% The cause should always be wrapped in either `io` or
+%% `device`. If it is wrapped in `io` we know that the
+%% error originated in the io module. If it is wrapped
+%% in `device`, the error came from the called io device.
+
+%% arguments, whereis(Io) failed
+format_io_error(_, _, {io, arguments}, true) ->
+    [device_arguments];
+format_io_error(_, _, {io, arguments}, false) ->
+    [{general,device_arguments}];
+%% terminated, monitor(Io) failed
+format_io_error(_, _, {io, terminated}, true) ->
+    [device_terminated];
+format_io_error(_, _, {io, terminated}, false) ->
+    [{general,device_terminated}];
+%% Strip the wrapping as we no longer need it
+format_io_error(Fn, Args, {device, Cause}, HasDevice) ->
+    format_io_error_cause(Fn, Args, Cause, HasDevice).
+
+%% Could not translate from unicode to latin1
+format_io_error_cause(_, _, {no_translation, In, Out}, true) ->
+    [{no_translation, In, Out}];
+format_io_error_cause(_, _, {no_translation, In, Out}, false) ->
+    [{general,{no_translation, In, Out}}];
+format_io_error_cause(format, Args, Cause, HasDevice) ->
+    case maybe_posix_message(Cause, HasDevice) of
+        unknown ->
+            if
+                HasDevice ->
+                    [[]] ++ check_io_format(tl(Args), Cause);
+                not HasDevice ->
+                    check_io_format(Args, Cause)
+            end;
+        PosixError ->
+            PosixError
+    end;
+format_io_error_cause(put_chars, Args, Cause, HasDevice) ->
+    Data = if HasDevice -> hd(tl(Args)); not HasDevice -> hd(Args) end,
+    case maybe_posix_message(Cause, HasDevice) of
+        unknown ->
+            [[] || HasDevice] ++
+                case unicode_char_data(Data) of
+                    [] -> [{general,{unknown_error,Cause}}];
+                    InvalidData ->
+                        [InvalidData]
+                end;
+        PosixError ->
+            PosixError ++ [unicode_char_data(Data)]
+    end;
+format_io_error_cause(Fn, _Args, Cause, HasDevice)
+  when Fn =:= write; Fn =:= nl ->
+    case maybe_posix_message(Cause, HasDevice) of
+        unknown ->
+            [{general,{unknown_error,Cause}}];
+        PosixError ->
+            PosixError
+    end;
+format_io_error_cause(_, _, _, _HasDevice) ->
+    [].
+
+maybe_posix_message(Cause, HasDevice) ->
+    case erl_posix_msg:message(Cause) of
+        "unknown POSIX error" ->
+            unknown;
+        PosixStr when HasDevice ->
+            [io_lib:format("~ts (~p)",[PosixStr, Cause])];
+        PosixStr when not HasDevice ->
+            [{general,io_lib:format("~ts (~p)",[PosixStr, Cause])}]
+    end.
+
+check_io_format([Fmt], Cause) ->
+    check_io_format([Fmt, []], Cause);
+check_io_format([Fmt, Args], Cause) ->
+    case is_io_format(Fmt) of
+        false ->
+            [invalid_format, must_be_list(Args)] ++
+                case (is_pid(Fmt) or is_atom(Fmt)) and is_io_format(Args) of
+                    true ->
+                        %% The user seems to have called io:format(Dev,"string").
+                        [{general,missing_argument_list}];
+                    false ->
+                        []
+                end;
+        _ when not is_list(Args) ->
+                [[],must_be_list(Args)];
+        true ->
+            case erl_lint:check_format_string(Fmt) of
+                {error,S} ->
+                    [io_lib:format("format string invalid (~ts)",[S])];
+                {ok,ArgTypes} when length(ArgTypes) =/= length(Args) ->
+                    [<<"wrong number of arguments">>] ++
+                        %% The user seems to have called io:format(user,"string")
+                        [{general,missing_argument_list} || is_atom(Fmt)];
+                {ok,ArgTypes} ->
+                    case check_io_arguments(ArgTypes, Args) of
+                        [] when Cause =:= format ->
+                            [format_failed];
+                        [] ->
+                            try io_lib:format(Fmt, Args) of
+                                _ ->
+                                    [io_lib:format("unknown error: ~p",[Cause])]
+                            catch _:_ ->
+                                    [format_failed]
+                            end;
+                        ArgErrors ->
+                            ArgErrors
+                    end
+            end
+    end.
+
+is_io_format(Fmt) when is_list(Fmt) ->
+    try lists:all(fun erlang:is_integer/1, Fmt) of
+        Res -> Res
+    catch _:_ ->
+            false
+    end;
+is_io_format(Fmt) when is_atom(Fmt); is_binary(Fmt) ->
+    true;
+is_io_format(_Fmt) ->
+    false.
+
+check_io_arguments(Types, Args) ->
+    case check_io_arguments(Types, Args, 1) of
+        [] ->
+            [];
+        Checks ->
+            [[],lists:join("\n",Checks)]
+    end.
+
+check_io_arguments([], [], _No) ->
+    [];
+check_io_arguments([Type|TypeT], [Arg|ArgT], No) ->
+    case Type of
+        float when is_float(Arg) ->
+            check_io_arguments(TypeT, ArgT, No+1);
+        int when is_integer(Arg) ->
+            check_io_arguments(TypeT, ArgT, No+1);
+        term ->
+            check_io_arguments(TypeT, ArgT, No+1);
+        string when is_atom(Arg); is_binary(Arg) ->
+            check_io_arguments(TypeT, ArgT, No+1);
+        string when is_list(Arg) ->
+            try unicode:characters_to_binary(Arg) of
+                _ ->
+                    check_io_arguments(TypeT, ArgT, No+1)
+            catch _:_ ->
+                    [io_lib:format("element ~B must be of type ~p", [No, string]) |
+                    check_io_arguments(TypeT, ArgT, No+1)]
+            end;
+        int ->
+            [io_lib:format("element ~B must be of type ~p", [No, integer]) |
+             check_io_arguments(TypeT, ArgT, No+1)];
+        _ when Type =:= float; Type =:= string ->
+            [io_lib:format("element ~B must be of type ~p", [No, Type]) |
+             check_io_arguments(TypeT, ArgT, No+1)]
+    end.
+
 format_ets_error(delete_object, Args, Cause) ->
     format_object(Args, Cause);
 format_ets_error(give_away, [_Tab,Pid,_Gift]=Args, Cause) ->
@@ -683,6 +860,8 @@ is_update_op(Incr) ->
 
 format_error_map([""|Es], ArgNum, Map) ->
     format_error_map(Es, ArgNum + 1, Map);
+format_error_map([{general, E}|Es], ArgNum, Map) ->
+    format_error_map(Es, ArgNum, Map#{ general => expand_error(E)});
 format_error_map([E|Es], ArgNum, Map) ->
     format_error_map(Es, ArgNum + 1, Map#{ArgNum => expand_error(E)});
 format_error_map([], _, Map) ->
@@ -813,14 +992,27 @@ expand_error(counter_not_integer) ->
     <<"the value in the given position, in the object, is not an integer">>;
 expand_error(dead_process) ->
     <<"the pid refers to a terminated process">>;
+expand_error(device_arguments) ->
+    <<"the device does not exist">>;
+expand_error(device_terminated) ->
+    <<"the device has terminated">>;
 expand_error(domain_error) ->
     <<"is outside the domain for this function">>;
 expand_error(empty_binary) ->
     <<"a zero-sized binary is not allowed">>;
 expand_error(empty_tuple) ->
     <<"is an empty tuple">>;
+expand_error(format_failed) ->
+    <<"failed to format string">>;
+expand_error(invalid_format) ->
+    <<"not a valid format string">>;
+expand_error(missing_argument_list) ->
+    <<"possibly missing argument list">>;
 expand_error(name_already_exists) ->
     <<"table name already exists">>;
+expand_error({no_translation, In, Out}) ->
+    unicode:characters_to_binary(
+      io_lib:format("device failed to transcode string from ~p to ~p", [In, Out]));
 expand_error(not_atom) ->
     <<"not an atom">>;
 expand_error(not_binary) ->
@@ -861,6 +1053,9 @@ expand_error(range) ->
     <<"out of range">>;
 expand_error(same_as_keypos) ->
     <<"the position is the same as the key position">>;
+expand_error({unknown_error,Cause}) ->
+    unicode:characters_to_binary(
+      io_lib:format("unknown error: ~p", [Cause]));
 expand_error(update_op_range) ->
     <<"the position in the update operation is out of range">>;
 expand_error(Other) ->
diff --git a/lib/stdlib/test/error_info_lib.erl b/lib/stdlib/test/error_info_lib.erl
index 81c0cbfc2e..8a10b71409 100644
--- a/lib/stdlib/test/error_info_lib.erl
+++ b/lib/stdlib/test/error_info_lib.erl
@@ -32,7 +32,13 @@ test_error_info(Module, L0, Options) ->
                                   [{F,A} || {F,A} <- L0, is_integer(A)]),
     Bifs0 = get_bifs(Module, Options),
     Bifs = ordsets:from_list(Bifs0),
-    NYI = [{F,lists:duplicate(A, '*'),nyi} || {F,A} <- Bifs -- Tests],
+    NYI =
+        case lists:member(allow_nyi, Options) of
+            false ->
+                [{F,lists:duplicate(A, '*'),nyi} || {F,A} <- Bifs -- Tests];
+            true ->
+                []
+        end,
     L = lists:sort(NYI ++ L1),
     do_error_info(L, Module, []).
 
@@ -67,8 +73,11 @@ do_error_info([], _Module, Errors0) ->
     end.
 
 eval_bif_error(F, Args, Opts, T, Module, Errors0) ->
+    OldGl = group_leader(),
+    group_leader(proplists:get_value(gl, Opts, OldGl), self()),
     try apply(Module, F, Args) of
         Result ->
+            group_leader(OldGl, self()),
             case lists:member(no_fail, Opts) of
                 true ->
                     do_error_info(T, Module, Errors0);
@@ -77,6 +86,7 @@ eval_bif_error(F, Args, Opts, T, Module, Errors0) ->
             end
     catch
         error:Reason:Stk ->
+            group_leader(OldGl, self()),
             AllowRename = lists:member(allow_rename, Opts),
             SF = fun(Mod, _, _) -> Mod =:= test_server end,
             Str = erl_error:format_exception(error, Reason, Stk, #{stack_trim_fun => SF}),
@@ -135,5 +145,8 @@ eval_bif_error(F, Args, Opts, T, Module, Errors0) ->
                     do_error_info(T, Module, Errors);
                 _ ->
                     do_error_info(T, Module, Errors0)
-            end
+            end;
+        E:R:ST ->
+            group_leader(OldGl, self()),
+            erlang:raise(E,R,ST)
     end.
diff --git a/lib/stdlib/test/io_SUITE.erl b/lib/stdlib/test/io_SUITE.erl
index 4adecaff23..2dacabf7b5 100644
--- a/lib/stdlib/test/io_SUITE.erl
+++ b/lib/stdlib/test/io_SUITE.erl
 	 maps/1, coverage/1, otp_14178_unicode_atoms/1, otp_14175/1,
          otp_14285/1, limit_term/1, otp_14983/1, otp_15103/1, otp_15076/1,
          otp_15159/1, otp_15639/1, otp_15705/1, otp_15847/1, otp_15875/1,
-         github_4801/1, chars_limit/1]).
+         github_4801/1, chars_limit/1, error_info/1]).
 
 -export([pretty/2, trf/3]).
 
@@ -66,7 +66,8 @@ all() ->
      io_lib_width_too_small, io_with_huge_message_queue,
      format_string, maps, coverage, otp_14178_unicode_atoms, otp_14175,
      otp_14285, limit_term, otp_14983, otp_15103, otp_15076, otp_15159,
-     otp_15639, otp_15705, otp_15847, otp_15875, github_4801, chars_limit].
+     otp_15639, otp_15705, otp_15847, otp_15875, github_4801, chars_limit,
+     error_info].
 
 %% Error cases for output.
 error_1(Config) when is_list(Config) ->
@@ -2986,3 +2987,108 @@ chars_limit(_Config) ->
             What <- [List, Tuple, Map, Record]
         ],
     ok.
+
+error_info(_Config) ->
+
+    FullDev =
+        fun() ->
+                {ok, Dev} = file:open("/dev/full",[read, write]),
+                Dev
+        end,
+
+    Latin1Dev = fun() ->
+                        {ok, Dev} = file:open("/dev/full",[read, write,
+                                                           {encoding, latin1}]),
+                        Dev
+                end,
+
+    DeadDev = spawn(fun() -> ok end),
+
+    UserDev = fun() -> whereis(user) end,
+    FileDev = FullDev,
+    TestServerDev = fun() -> group_leader() end,
+    ApplicationMasterDev =
+        fun() ->
+                {_,GL} = process_info(whereis(kernel_sup),group_leader),
+                GL
+        end,
+    GroupDev = TestServerDev,
+    StandardError = fun() -> whereis(standard_error) end,
+
+    L = [
+         {put_chars,[DeadDev,"test"],[{1,"terminated"}]},
+         {put_chars,["test"],[{gl,DeadDev},{general,"terminated"}]},
+         {put_chars,[?MODULE,"test"],[{1,"does not exist"}]},
+         {put_chars,[FullDev(),"test"], [{1,"no space left on device"}]},
+         {put_chars,["test"], [{gl,FullDev()},{general,"no space left on device"}]},
+         {put_chars,[Latin1Dev(),"Спутник-1"], [{1,"transcode"}]},
+         {put_chars,[a], [{1,"not valid character data"}]},
+
+         {write,[DeadDev,"test"],[{1,"terminated"}]},
+         {write,["test"],[{gl,DeadDev},{general,"terminated"}]},
+         {write,[?MODULE,"test"],[{1,"does not exist"}]},
+         {write,[FullDev(),"test"], [{1,"no space left on device"}]},
+         {write,["test"], [{gl,FullDev()},{general,"no space left on device"}]},
+
+         {nl,[DeadDev],[{1,"terminated"}]},
+         {nl,[?MODULE],[{1,"does not exist"}]},
+         {nl,[],[{gl,DeadDev},{general,"terminated"}]},
+         {nl,[FullDev()], [{1,"no space left on device"}]},
+         {nl,[], [{gl,FullDev()},{general,"no space left on device"}]},
+
+         [[{Format,[DeadDev,"test",[]],   [{1,"terminated"}]},
+           {Format,["test",[{gl,DeadDev},  {general,"terminated"}]]},
+           {Format,[?MODULE,"test",[]],   [{1,"does not exist"}]},
+           {Format,[FullDev(),"test",[]], [{1,"no space left on device"}]},
+           {Format,["test"], [{gl,FullDev()},{general,"no space left on device"}]},
+           {Format,[standard_io,"test"],  [{1,"wrong number of arguments"},
+                                           {general,"possibly missing argument list"}]},
+
+           %% Test a latin1 device
+           {Format,[Latin1Dev(), "~ts", [<<"Спутник-1"/utf8>>]],[{1,"transcode"}]},
+           {Format,["~ts", [<<"Спутник-1"/utf8>>]],[{gl,Latin1Dev()},{general,"transcode"}]},
+
+           %% The format error is reported differently
+           %% depending on the current group_leader.
+           %% The different group leaders we test are:
+           %%  * file_io_server
+           %%  * standard_error
+           %%  * test_server_gl
+           %%  * user
+           %%  * application_master
+           %%  * ssh_cli (TODO)
+           %%  * eunit (TODO)
+           %%  * group (TODO)
+           [ [{Format,[Device(),make_ref(),[]],    [{2,"format string"}]},
+              {Format,[Device(),"~p",make_ref()],  [{3, "not a list"}]},
+              {Format,[make_ref(),[]],[{gl,Device()},{1,"format string"}]},
+              {Format,["~p",make_ref()],[{gl,Device()},{2, "not a list"}]}]
+             || Device <- [UserDev, FileDev, TestServerDev, StandardError,
+                           GroupDev, ApplicationMasterDev]],
+
+           %% Test number of arguments
+           {Format,["~p",["Sputnik-1","Laika"]],[{1,"wrong number of arguments"}]},
+           {Format,[standard_io, "~p",["Sputnik-1","Laika"]],[{2,"wrong number of arguments"}]},
+
+           %% Test different formatting strings
+           {Format,["~B",["Sputnik-1"]],[{2,"1 must be of type integer"}]},
+           {Format,[standard_io, "~B",["Sputnik-1"]],[{3,"1 must be of type integer"}]},
+           {Format,["~b",["Sputnik-1"]],[{2,"1 must be of type integer"}]},
+           {Format,["~*b",["Sputnik-1",16]],[{2,"1 must be of type integer"}]},
+           {Format,["~*f",[1.0,1]],[{2,"1 must be of type integer\\n.*2 must be of type float"}]},
+           {Format,["~1.*f",[1.0,1]],[{2,"1 must be of type integer\\n.*2 must be of type float"}]},
+           {Format,["~*.*f",[a,b,c]],[{2,"1 must be of type integer\\n.*"
+                                       "2 must be of type integer\\n.*"
+                                       "3 must be of type float"}]},
+           {Format,["~s",["Спутник-1"]],[{1,"failed to format string"}]},
+           {Format,["~s",[1]],[{2,"1 must be of type string"}]},
+           {Format,["~s~s",[a,1]],[{2,"2 must be of type string"}]},
+           {Format,["~s",[[a]]],[{2,"1 must be of type string"}]}] || Format <- [format,fwrite]]
+
+        ],
+
+    try
+        error_info_lib:test_error_info(io, lists:flatten(L), [allow_nyi])
+    after
+        dbg:stop_clear()
+    end.
-- 
2.26.2

Places

File 1305-stdlib-Implement-error_info-for-the-io-module.patch of Package erlang (Revision c577547aad4fe182a4c53d158b3f41d4)

Places