File 8082-debugger-Support-the-fun-Name-Arity-syntax... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 8082-debugger-Support-the-fun-Name-Arity-syntax-for-BIFs.patch of Package erlang (Revision 2d0cd4533106aac34fcd08e582375727)

Currently displaying revision 2d0cd4533106aac34fcd08e582375727 , Show latest

From eb9d3e774f9a32d0d81be2f5522233a1cf771b76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 29 Oct 2024 08:57:02 +0100
Subject: [PATCH 2/2] debugger: Support the fun Name/Arity syntax for BIFs

While at it, also extend fun_SUITE.erl by copying the latest
version of fun_SUITE.erl from the compiler test suite.
---
 lib/debugger/src/dbg_iload.erl  |  15 +-
 lib/debugger/test/fun_SUITE.erl | 706 +++++++++++++++++++++++---------
 2 files changed, 518 insertions(+), 203 deletions(-)

diff --git a/lib/debugger/src/dbg_iload.erl b/lib/debugger/src/dbg_iload.erl
index abb3529f5b..aba270a929 100644
--- a/lib/debugger/src/dbg_iload.erl
+++ b/lib/debugger/src/dbg_iload.erl
@@ -528,10 +528,17 @@ expr({'fun',Anno,{clauses,Cs0}}, _Lc, St) ->
 expr({'fun',Anno,{function,F,A}}, _Lc, _St) ->
     %% New R8 format (abstract_v2).
     Line = ln(Anno),
-    As = new_vars(A, Line),
-    Name = new_fun_name(),
-    Cs = [{clause,Line,As,[],[{local_call,Line,F,As,true}]}],
-    {make_fun,Line,Name,Cs};
+    case erl_internal:bif(F, A) of
+        true ->
+            %% Auto-imported BIF. Create an external fun.
+            {value,Line,fun erlang:F/A};
+        false ->
+            %% A local function.
+            As = new_vars(A, Line),
+            Name = new_fun_name(),
+            Cs = [{clause,Line,As,[],[{local_call,Line,F,As,true}]}],
+            {make_fun,Line,Name,Cs}
+    end;
 expr({named_fun,Anno,FName,Cs0}, _Lc, St) ->
     Cs = fun_clauses(Cs0, St),
     Name = new_fun_name(),
diff --git a/lib/debugger/test/fun_SUITE.erl b/lib/debugger/test/fun_SUITE.erl
index f970ed0438..cf7abfe71a 100644
--- a/lib/debugger/test/fun_SUITE.erl
+++ b/lib/debugger/test/fun_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1999-2021. All Rights Reserved.
+%% Copyright Ericsson AB 1999-2024. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -16,238 +16,163 @@
 %% limitations under the License.
 %%
 %% %CopyrightEnd%
-%%
-
 %%
 -module(fun_SUITE).
 
--export([all/0, suite/0,groups/0,init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,end_per_testcase/2,
-	 init_per_suite/1,end_per_suite/1,
-	 good_call/1,bad_apply/1,bad_fun_call/1,badarity/1,
-	 ext_badarity/1,otp_6061/1,external/1,eep37/1]).
+-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
+         init_per_group/2,end_per_group/2,
+         test1/1,overwritten_fun/1,otp_7202/1,bif_fun/1,
+         external/1,eep37/1,badarity/1,badfun/1,
+         duplicated_fun/1,unused_fun/1,parallel_scopes/1,
+         coverage/1,leaky_environment/1]).
 
 %% Internal exports.
--export([nothing/0,call_me/1]).
+-export([call_me/1,dup1/0,dup2/0]).
 
 -include_lib("common_test/include/ct.hrl").
 
-suite() ->
-    [{ct_hooks,[ts_install_cth]},
-     {timetrap,{minutes,1}}].
+suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
-    cases().
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
+    [{group,p}].
 
-cases() -> 
-    [good_call, bad_apply, bad_fun_call, badarity,
-     ext_badarity, otp_6061, external, eep37].
+groups() ->
+    [{p,[parallel],
+      [test1,overwritten_fun,otp_7202,bif_fun,external,eep37,
+       badarity,badfun,duplicated_fun,unused_fun,
+       parallel_scopes,
+       coverage,leaky_environment]}].
 
-init_per_testcase(_Case, Config) ->
+init_per_suite(Config) ->
     test_lib:interpret(?MODULE),
+    true = lists:member(?MODULE, int:interpreted()),
     Config.
 
-end_per_testcase(_Case, _Config) ->
+end_per_suite(_Config) ->
     ok.
 
-init_per_suite(Config) when is_list(Config) ->
-    test_lib:interpret(?MODULE),
-    true = lists:member(?MODULE, int:interpreted()),
+init_per_group(_GroupName, Config) ->
     Config.
 
-end_per_suite(Config) when is_list(Config) ->
-    ok.
-
-good_call(Config) when is_list(Config) ->
-    F = fun() -> ok end,
-    ok = F(),
-    FF = fun ?MODULE:nothing/0,
-    ok = FF(),
-    ok.
+end_per_group(_GroupName, Config) ->
+    Config.
 
-%% Test that the correct EXIT code is returned for all types of bad funs.
-bad_apply(Config) when is_list(Config) ->
-    bad_apply_fc(42, [0]),
-    bad_apply_fc(xx, [1]),
-    bad_apply_fc({}, [2]),
-    bad_apply_fc({1}, [3]),
-    bad_apply_fc({1,2,3}, [4]),
-    bad_apply_fc({1,2,3}, [5]),
-    bad_apply_fc({1,2,3,4}, [6]),
-    bad_apply_fc({1,2,3,4,5,6}, [7]),
-    bad_apply_fc({1,2,3,4,5}, [8]),
-    bad_apply_badarg({1,2}, [9]),
-    ok.
+%%% The help functions below are copied from emulator:bs_construct_SUITE.
 
-bad_apply_fc(Fun, Args) ->
-    Res = (catch apply(Fun, Args)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res of
-	{'EXIT',{{badfun,Fun},_Where}} ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res]);
-	Other ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res]),
-	    ct:fail({bad_result,Other})
-    end.
+-define(T(B, L), {fun() -> B end(), ??B, L}).
 
-bad_apply_badarg(Fun, Args) ->
-    Res = (catch apply(Fun, Args)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res of
-	{'EXIT',{{badfun,Fun},_Where}} ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res]);
-	Other ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res]),
-	    ct:fail({bad_result, Other})
-    end.
+l1() ->
+    [
+     ?T((begin _A = 3, F = fun(_A) -> 1; (_) -> 2 end, F(2) end), 1),
+     ?T((begin G = fun(1=0) -> ok end, {'EXIT',_} = (catch G(2)), ok end), ok),
+     ?T((begin F = fun(_, 1) -> 1; (F, N) -> N * F(F, N-1) end, F(F, 5) end), 120),
+     ?T((begin F = fun(_, 1) -> 1; (F, N) -> N * F(F, N-1) end, F(F, 1), ok end), ok)
+    ].
 
-%% Try directly calling bad funs.
-bad_fun_call(Config) when is_list(Config) ->
-    bad_call_fc(42),
-    bad_call_fc(xx),
-    bad_call_fc({}),
-    bad_call_fc({1}),
-    bad_call_fc({1,2,3}),
-    bad_call_fc({1,2,3}),
-    bad_call_fc({1,2,3,4}),
-    bad_call_fc({1,2,3,4,5,6}),
-    bad_call_fc({1,2,3,4,5}),
-    bad_call_fc({1,2}),
+test1(Config) when is_list(Config) ->
+    lists:foreach(fun one_test/1, eval_list(l1(), [])),
     ok.
 
-bad_call_fc(Fun) ->
-    Args = [some,stupid,args],
-    Res = (catch Fun(Args)),
-    case Res of
-	{'EXIT',{{badfun,Fun},_Where}} ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]);
-	Other ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]),
-	    ct:fail({bad_result,Other})
+evaluate(Str, Vars) ->
+    {ok,Tokens,_} =
+        erl_scan:string(Str ++ " . "),
+    {ok, [Expr]} = erl_parse:parse_exprs(Tokens),
+    case erl_eval:expr(Expr, Vars) of
+        {value, Result, _} ->
+            Result
     end.
 
-%% Call and apply valid external funs with wrong number of arguments.
-
-badarity(Config) when is_list(Config) ->
-    Fun = fun() -> ok end,
-    Stupid = {stupid,arguments},
-    Args = [some,{stupid,arguments},here],
-
-    %% Simple call.
-
-    Res = (catch Fun(some, Stupid, here)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res of
-	{'EXIT',{{badarity,{Fun,Args}},[_|_]}} ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]);
-	_ ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]),
-	    ct:fail({bad_result,Res})
-    end,
+eval_list([], _Vars) ->
+    [];
+eval_list([{C_bin, Str, Bytes} | Rest], Vars) ->
+    case catch evaluate(Str, Vars) of
+        {'EXIT', Error} ->
+            io:format("Evaluation error: ~p, ~p, ~p~n", [Str, Vars, Error]),
+            exit(Error);
+        E_bin ->
+            [{C_bin, E_bin, Str, Bytes} | eval_list(Rest, Vars)]
+    end.
 
-    %% Apply.
-
-    Res2 = (catch apply(Fun, Args)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res2 of
-	{'EXIT',{{badarity,{Fun,Args}},[_|_]}} ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res2]);
-	_ ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res2]),
-	    ct:fail({bad_result,Res2})
+one_test({C, E, Str, Correct}) ->
+    io:format("  ~s, ~p~n", [Str, Correct]),
+    if
+        C == Correct ->
+            ok;
+        true ->
+            io:format("ERROR: Compiled: ~p. Expected ~p. Got ~p.~n",
+                      [Str, Correct, C]),
+            ct:fail(comp)
     end,
-    ok.
-
-%% Call and apply valid external funs with wrong number of arguments.
-
-ext_badarity(Config) when is_list(Config) ->
-    Fun = fun ?MODULE:nothing/0,
-    Stupid = {stupid,arguments},
-    Args = [some,{stupid,arguments},here],
-
-    %% Simple call.
+    if
+        E == Correct ->
+            ok;
+        true ->
+            io:format("ERROR: Interpreted: ~p. Expected ~p. Got ~p.~n",
+                      [Str, Correct, E]),
+            ct:fail(comp)
+    end.
 
-    Res = (catch Fun(some, Stupid, here)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res of
-	{'EXIT',{{badarity,{Fun,Args}},_}} ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]);
-	_ ->
-	    ok = io:format("~p(~p) -> ~p\n", [Fun,Args,Res]),
-	    ct:fail({bad_result,Res})
-    end,
+-record(b, {c}).
 
-    %% Apply.
-
-    Res2 = (catch apply(Fun, Args)),
-    erlang:garbage_collect(),
-    erlang:yield(),
-    case Res2 of
-	{'EXIT',{{badarity,{Fun,Args}},_}} ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res2]);
-	_ ->
-	    ok = io:format("apply(~p, ~p) -> ~p\n", [Fun,Args,Res2]),
-	    ct:fail({bad_result,Res2})
-    end,
-    ok.
+%% OTP-7102. (Thanks to Simon Cornish.)
 
-nothing() ->
+overwritten_fun(Config) when is_list(Config) ->
+    {a2,a} = overwritten_fun_1(a),
+    {a2,{b,c}} = overwritten_fun_1(#b{c=c}),
+    one = overwritten_fun_1(#b{c=[]}),
     ok.
 
-%% Test handling of fun expression referring to uninterpreted code.
-otp_6061(Config) when is_list(Config) ->
-
-    OrigFlag = process_flag(trap_exit, true),
-
-    Self = self(),
-    Pid = spawn_link(fun() -> test_otp_6061(Self) end),
-
-    receive
-	working ->
-	    ok;
-	not_working ->
-	    ct:fail(not_working);
-	{'EXIT', Pid, Reason} ->
-	    ct:fail({crash, Reason})
-    after
-	5000 ->
-	    ct:fail(timeout)
-    end,
-
-    process_flag(trap_exit, OrigFlag),
+overwritten_fun_1(A) ->
+    F = fun() ->
+                {ok, A}
+        end,
+    if A#b.c == [] ->
+            one;
+       true ->
+            case F() of
+                {ok, A2} ->
+                    {a2, A2};
+                _ ->
+                    three
+            end
+    end.
 
+%% OTP-7202. The liveness calculation for the make_fun2 instruction was wrong.
+
+otp_7202(Config) when is_list(Config) ->
+    otp_7202().
+
+otp_7202() ->
+    List = [a],
+    Error = case otp_7202_func() of
+                no_value -> true;
+                {ok, V} -> V
+            end,
+    lists:foreach(fun(_E) ->
+                          case Error of
+                              true ->
+                                  ok;
+                              false ->
+                                  ok
+                          end
+                  end, List).
+
+otp_7202_func() ->
+    no_value.
+
+bif_fun(Config) when is_list(Config) ->
+    F = fun abs/1,
+    5 = F(-5),
     ok.
 
-test_otp_6061(Starter) ->
-    Passes = [2],
-    PassesF = [fun() -> Starter ! not_working end,
-	       fun() -> Starter ! working end,
-	       fun() -> Starter ! not_working end],
-    lists:foreach(fun(P)->(lists:nth(P,PassesF))() end,Passes).
-
 -define(APPLY(M, F, A), (fun(Fun) -> {ok,{a,b}} = Fun({a,b}) end)(fun M:F/A)).
 -define(APPLY2(M, F, A),
-	(fun(Map) ->
-		 Id = fun(I) -> I end,
-		 List = [x,y],
-		 List = Map(Id, List),
-		 {type,external} = erlang:fun_info(Map, type)
-	 end)(fun M:F/A)).
+        (fun(Map) ->
+                 Id = fun(I) -> I end,
+                 List = [x,y],
+                 List = Map(Id, List),
+                 {type,external} = erlang:fun_info(Map, type)
+         end)(fun M:F/A)).
 
 external(Config) when is_list(Config) ->
     Mod = id(?MODULE),
@@ -276,22 +201,405 @@ external(Config) when is_list(Config) ->
     ?APPLY2(ListsMod, ListsMap, 2),
     ?APPLY2(ListsMod, ListsMap, ListsArity),
 
+    42 = (fun erlang:abs/1)(-42),
+    42 = (id(fun erlang:abs/1))(-42),
+    42 = apply(fun erlang:abs/1, [-42]),
+    42 = apply(id(fun erlang:abs/1), [-42]),
+    6 = (fun lists:sum/1)([1,2,3]),
+    6 = (id(fun lists:sum/1))([1,2,3]),
+
+    {'EXIT',{{badarity,_},_}} = (catch (fun lists:sum/1)(1, 2, 3)),
+    {'EXIT',{{badarity,_},_}} = (catch (id(fun lists:sum/1))(1, 2, 3)),
+    {'EXIT',{{badarity,_},_}} = (catch apply(fun lists:sum/1, [1,2,3])),
+
+    {'EXIT',{badarg,_}} = (catch bad_external_fun()),
+
     ok.
 
 call_me(I) ->
     {ok,I}.
 
-eep37(Config) when is_list(Config) ->
+bad_external_fun() ->
+    V0 = idea,
+    fun V0:V0/V0,                               %Should fail.
+    never_reached.
+
+%% Named funs.
+eep37(_Config) ->
+    eep37_basic(),
+    eep37_dup(),
+    eep37_gh6515(),
+    ok.
+
+eep37_basic() ->
     F = fun Fact(N) when N > 0 -> N * Fact(N - 1); Fact(0) -> 1 end,
     Add = fun _(N) -> N + 1 end,
-    UnusedName = fun BlackAdder(N) -> N + 42 end,
+    UnusedName = fun _BlackAdder(N) -> N + 42 end,
     720 = F(6),
     10 = Add(9),
     50 = UnusedName(8),
-    [1,1,2,6,24,120] = lists:map(F, lists:seq(0, 5)),
-    {'EXIT',{function_clause,_}} = (catch lists:map(fun G() -> G() end, [1])),
-    {'EXIT',{{badarity,_},_}} = (catch F()),
+    ok.
+
+eep37_dup() ->
+    dup1 = (dup1())(),
+    dup2 = (dup2())(),
+    ok.
+
+dup1() ->
+    fun _F() -> dup1 end.
+
+dup2() ->
+    fun _F() -> dup2 end.
+
+eep37_gh6515() ->
+    {0,F1} = eep37_gh6515_1(),
+    F1 = F1(),
+
+    [0,F2] = eep37_gh6515_2(),
+    1 = F2(0),
+    120 = F2(5),
+
+    ok.
+
+eep37_gh6515_1() ->
+    {case [] of
+         #{} ->
+             X = 0;
+         X ->
+             0
+     end,
+     fun X() ->
+             X
+     end}.
+
+eep37_gh6515_2() ->
+    [case [] of
+         #{} ->
+             Fact = 0;
+         Fact ->
+             0
+     end,
+     fun Fact(N) when N > 0 ->
+             N * Fact(N - 1);
+         Fact(0) -> 1
+     end].
+
+badarity(Config) when is_list(Config) ->
+    {'EXIT',{{badarity,{_,[]}},_}} = (catch (fun badarity/1)()),
+    {'EXIT',{{badarity,_},_}} = (catch fun() -> 42 end(0)),
+    ok.
+
+badfun(_Config) ->
+    X = not_a_fun,
+    expect_badfun(42, catch 42()),
+    expect_badfun(42.0, catch 42.0(1)),
+    expect_badfun(X, catch X()),
+    expect_badfun(X, catch X(1)),
+    Len = length(atom_to_list(X)),
+    expect_badfun(Len, catch begin length(atom_to_list(X)) end(1)),
+
+    expect_badfun(42, catch 42(put(?FUNCTION_NAME, yes))),
+    %% TODO: Investigate difference in behavior compared to compiler.
+    %% yes = erase(?FUNCTION_NAME),
+
+    expect_badfun(X, catch X(put(?FUNCTION_NAME, of_course))),
+    %% TODO: Investigate difference in behavior compared to compiler.
+    %% of_course = erase(?FUNCTION_NAME),
+
+    %% A literal as a Fun used to crash the code generator. This only happened
+    %% when type optimization had reduced `Fun` to a literal, hence the match.
+    Literal = fun(literal = Fun) ->
+                      Fun()
+              end,
+    expect_badfun(literal, catch Literal(literal)),
+
+    ok.
+
+expect_badfun(Term, Exit) ->
+    {'EXIT',{{badfun,Term},_}} = Exit.
+
+duplicated_fun(_Config) ->
+    try
+        %% The following code used to crash the compiler before
+        %% v3_core:is_safe/1 was corrected to consider fun variables
+        %% unsafe.
+        id([print_result_paths_fun = fun duplicated_fun_helper/1]),
+        ct:error(should_fail)
+    catch
+        error:{badmatch,F} when is_function(F, 1) ->
+            ok
+    end.
+
+duplicated_fun_helper(_) ->
+    ok.
+
+%% ERL-1166: beam_kernel_to_ssa would crash if a fun was unused.
+unused_fun(_Config) ->
+    _ = fun() -> ok end,
+    try id(ok) of
+        _ -> fun() -> ok end
+    catch _ -> ok end,
+    ok.
+
+parallel_scopes(_Config) ->
+    1 = parallel_scopes_1a(),
+    1 = parallel_scopes_1b(),
+    {'EXIT',{{badmatch,99},_}} = catch parallel_scopes_1c(),
+
+    10 = parallel_scopes_2a(),
+    {'EXIT',{{badmatch,15},_}} = catch parallel_scopes_2b(),
+    500 = parallel_scopes_2c(500, 500),
+    {'EXIT',{{badmatch,1000},_}} = catch parallel_scopes_2c(500, 1000),
+    600 = parallel_scopes_2d(600, 600),
+    {'EXIT',{{badmatch,1000},_}} = catch parallel_scopes_2d(600, 1000),
+    {a,20} = parallel_scopes_2e(20, 20),
+    {'EXIT',{{badmatch,{a,25}},_}} = catch parallel_scopes_2e(20, 25),
+
+    {[42,2],42,a} = parallel_scopes_3(a),
+
+    42 = parallel_scopes_4a(id(42), id(42)),
+    {'EXIT',{{badmatch,77},_}} = catch parallel_scopes_4a(42, 77),
+    42 = parallel_scopes_4b(id(42), id(42)),
+    {'EXIT',{{badmatch,77},_}} = catch parallel_scopes_4b(42, 77),
+    [same,2,same,2] = parallel_scopes_4c(id(same), id(same)),
+    {'EXIT',{{badmatch,55},_}} = catch parallel_scopes_4c(42, 55),
+
+    33 = parallel_scopes_5(id(33), id(33)),
+    {'EXIT',{{badmatch,44},_}} = catch parallel_scopes_5(33, 44),
+
+    99 = parallel_scopes_6(id(99), id(99)),
+    {'EXIT',{{badmatch,88},_}} = catch parallel_scopes_6(77, 88),
+
+    99 = parallel_scopes_7(id(99), id(99)),
+    {'EXIT',{{badmatch,88},_}} = catch parallel_scopes_7(77, 88),
+
+    199 = parallel_scopes_8(id(199), id(199)),
+    {'EXIT',{{badmatch,200},_}} = catch parallel_scopes_8(id(199), id(200)),
+
+    {299,299+299} = parallel_scopes_9(id(299), id(299), id(299+299)),
+    {'EXIT',{{badmatch,300},_}} = catch parallel_scopes_9(id(299), id(300), id(0)),
+    {'EXIT',{{badmatch,0},_}} = catch parallel_scopes_9(id(299), id(299), id(0)),
+
+    999 = parallel_scopes_10(false, 999, ignored, 999),
+    {'EXIT',{{badmatch,999},_}} = catch parallel_scopes_10(false, 700, ignored, 700),
+    %% TODO: Investigate difference in behavior compared to compiler.
+    %% {'EXIT',{{badmatch,1000},_}} = catch parallel_scopes_10(false, 999, ignored, 1000),
+    999 = parallel_scopes_10(true, 999, 999, ignored),
+    333 = parallel_scopes_10(true, 333, 333, ignored),
+    {'EXIT',{{badmatch,901},_}} = catch parallel_scopes_10(true, 900, 901, ignored),
+
+    889 = parallel_scopes_11(889, 889, 889),
+    %% TODO: Investigate difference in behavior compared to compiler.
+    %% {'EXIT',{{badmatch,800},_}} = catch parallel_scopes_11(889, 800, 889),
+    {'EXIT',{{badmatch,810},_}} = catch parallel_scopes_11(889, 889, 810),
+    {'EXIT',{{badmatch,889},_}} = catch parallel_scopes_11(a, a, a),
+
+    333 = parallel_scopes_12(333, 333, 333),
+    %% TODO: Investigate difference in behavior compared to compiler.
+    %% {'EXIT',{{badmatch,other},_}} = catch parallel_scopes_12(333, other, 333),
+    {'EXIT',{{badmatch,nope},_}} = catch parallel_scopes_12(333, 333, nope),
+
+    [1,100] = parallel_scopes_13(99, 100),
+    {'EXIT',{{badmatch,no},_}} = catch parallel_scopes_13(no, 100),
+    {'EXIT',{{badmatch,nope},_}} = catch parallel_scopes_13(99, nope),
+
+    ok.
+
+parallel_scopes_1a() ->
+    (begin X=1, true end
+     and
+     begin F=(fun () -> X=2 end), F(), true end) andalso X.
+
+parallel_scopes_1b() ->
+    (begin X=1, true end
+     and
+     begin F=(fun () -> X=2 end), F(), true end) andalso (X = 1).
+
+parallel_scopes_1c() ->
+    (begin X=1, true end
+     and
+     begin F=(fun () -> X=2 end), F(), true end) andalso (X = 99).
+
+parallel_scopes_2a() ->
+    begin X=10, true end
+        and
+        begin F=(fun () -> X=20 end), F(), true end
+        and
+        begin X=10, true end andalso X.
+
+parallel_scopes_2b() ->
+    begin X=10, true end
+        and
+        begin F=(fun () -> X=20 end), F(), true end
+        and
+        begin X=15, true end andalso X.
+
+parallel_scopes_2c(A, B) ->
+    begin X=A, true end
+        and
+        begin F = (fun () -> X = make_ref() end), F(), true end
+        and
+        begin X=B, true end andalso X.
+
+parallel_scopes_2d(A, B) ->
+    begin X=A, true end
+        and
+        begin F = (fun () -> X = make_ref() end), F(), true end
+        and
+        begin X=B, true end andalso (X = A).
+
+parallel_scopes_2e(A, B) ->
+    begin X = {a,A}, true end
+        and
+        begin F=(fun () -> X = 20 end), F(), true end
+        and
+        begin X = {a,B}, true end andalso X.
+
+parallel_scopes_3(A) ->
+    L = [X = id(42),
+         fun() -> X = 2 end()],
+    {L,X,A}.
+
+parallel_scopes_4a(A, B) ->
+    4 = length([X = A,
+                fun() -> X = 2 end(),
+                X = B,
+                fun() -> X = 2 end()]),
+    X.
+
+parallel_scopes_4b(A, B) ->
+    4 = length([X = A,
+                case id(true) of
+                    true ->
+                        fun() -> X = 2 end()
+                end,
+                X = B,
+                case id(false) of
+                    false ->
+                        fun() -> X = 2 end()
+                end]),
+    X.
+
+parallel_scopes_4c(A, B) ->
+    [X = A,
+     fun() -> X = 2 end(),
+     X = B,
+     fun() -> X = 2 end()].
+
+parallel_scopes_5(A, B) ->
+    4 = length([X = A,
+                [fun() -> X = 2 end()],
+                X = B |
+                case id(false) of
+                    false ->
+                        [fun() -> X = 2 end()]
+                end]),
+    X.
+
+parallel_scopes_6(A, B) ->
+    4 = tuple_size({X = A,
+                    fun() -> X = 40 end(),
+                    X = B,
+                    fun() -> X = 50 end()}),
+    X.
+
+parallel_scopes_7(A, B) ->
+    4 = tuple_size({X = A,
+                    [fun() -> X = 40 end()],
+                    X = B,
+                    [fun() -> X = 50 end()]}),
+    X.
+
+parallel_scopes_8(A, B) ->
+    _ = [X = id(A),
+         begin fun() -> X = 2 end(), X = id(B) end],
+    X.
+
+parallel_scopes_9(A, B, C) ->
+    3 = length([begin X = id(A), Y = id(A+B) end,
+                fun() -> X = 2 end(),
+                X = id(B)]),
+    {X,Y=C}.
+
+parallel_scopes_10(Bool, A, B, C) ->
+    T = {X = A,
+         case id(Bool) of
+             true ->
+                 fun() -> X = 999 end(),
+                 X = B;
+             false ->
+                 X = C,
+                 fun() -> X = 999 end()
+         end},
+    2 = tuple_size(T),
+    X.
+
+parallel_scopes_11(A, B, C) ->
+    T = {X = A,
+         case id(true) of
+             true ->
+                 X = B,
+                 2 = length([X = C, X = C]),
+                 fun() -> X = 889 end();
+             false ->
+                 X = cannot_happen
+         end},
+    2 = tuple_size(T),
+    X.
+
+parallel_scopes_12(A, B, C) ->
+    T = {X = A,
+         case id(true) of
+             true ->
+                 fun() -> X = whatever end(),
+                 2 = length([X = B, X = B]),
+                 X = C;
+             false ->
+                 X = cannot_happen
+         end},
+    2 = tuple_size(T),
+    X.
+
+parallel_scopes_13(A, B) ->
+    [X = 1,
+     fun() ->
+             X = id(whatever),
+             99 = A,
+             100 = B
+     end()].
+
+coverage(_Config) ->
+    ok = coverage_1(),
+
+    [2,3,4] = coverage_2(id([1,2,3])),
+
+    {42,F} = coverage_3(id({[], x})),
+    x = F(),
+
+    ok.
 
+coverage_1() ->
+    %% Cover a line in beam_ssa_pre_codegen:need_frame_1/2 when the
+    %% no_make_fun3 option is given.
+    catch
+        fun(whatever) -> 0;
+           ("abc") -> party
+        end,
+        ok.
+
+coverage_2(List) ->
+    %% Cover a line in beam_ssa_pre_codegen:need_frame_1/2 when the
+    %% no_make_fun3 option is given.
+    lists:map(fun(E) -> E + 1 end, List).
+
+%% Cover a line in beam_block when no_make_fun3 option is given.
+coverage_3({[], A}) ->
+    {id(42), fun() -> A end}.
+
+leaky_environment(_Config) ->
+    G = fun(X, Y) -> X + Y end,
+    F = fun(A) -> G(A, 0) end,
+    {'EXIT', {{badarity, {_, [1, flurb]}}, _}} = catch F(1, flurb),
     ok.
 
 id(I) ->
-- 
2.43.0

Places

File 8082-debugger-Support-the-fun-Name-Arity-syntax-for-BIFs.patch of Package erlang (Revision 2d0cd4533106aac34fcd08e582375727)

Places