File 2851-compiler-Remove-cerl_sets-usage.patch of Package erlang
From 827e8e6436bf6a34bbc2d9621c5fa0c941d3bb0e Mon Sep 17 00:00:00 2001
From: Wojtek Mach <wojtek@wojtekmach.pl>
Date: Thu, 14 Jan 2021 12:29:36 +0100
Subject: [PATCH 1/2] compiler: Remove cerl_sets usage
I used the following script to rewrite most call sites and I manually
fixed up the remaining `cerl_sets:from_list/1` ones.
#!/bin/sh
cd lib/compiler
for file in src/*.erl; do
sed -E -i.bak 's/cerl_sets:(set)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(add_element)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(is_element)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(del_element)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(union)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(intersection)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(is_disjoint)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(size)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(filter)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:(to_list)/sets:\1/' $file
sed -E -i.bak 's/cerl_sets:new\(\)/sets:new\(\[\{version, 2\}\]\)/' $file
sed -E -i.bak 's/cerl_sets:from_list\(([A-Z][A-Za-z0-9_]*)\)/sets:from_list\(\1, \[\{version, 2\}\]\)/' $file
rm -f $file.bak
done
---
lib/compiler/src/beam_asm.erl | 4 +-
lib/compiler/src/beam_clean.erl | 8 +--
lib/compiler/src/beam_digraph.erl | 12 ++--
lib/compiler/src/beam_jump.erl | 14 ++--
lib/compiler/src/beam_ssa.erl | 38 +++++------
lib/compiler/src/beam_ssa_bool.erl | 36 +++++------
lib/compiler/src/beam_ssa_dead.erl | 36 +++++------
lib/compiler/src/beam_ssa_funs.erl | 6 +-
lib/compiler/src/beam_ssa_opt.erl | 78 +++++++++++------------
lib/compiler/src/beam_ssa_pre_codegen.erl | 46 ++++++-------
lib/compiler/src/beam_ssa_throw.erl | 8 +--
lib/compiler/src/beam_ssa_type.erl | 8 +--
lib/compiler/src/beam_trim.erl | 10 +--
lib/compiler/src/beam_validator.erl | 34 +++++-----
lib/compiler/src/sys_core_alias.erl | 10 +--
lib/compiler/src/sys_core_fold.erl | 26 ++++----
lib/compiler/src/v3_core.erl | 6 +-
lib/compiler/src/v3_kernel.erl | 24 +++----
18 files changed, 202 insertions(+), 202 deletions(-)
diff --git a/lib/compiler/src/beam_asm.erl b/lib/compiler/src/beam_asm.erl
index b1cac9d171..d9de7031a0 100644
--- a/lib/compiler/src/beam_asm.erl
+++ b/lib/compiler/src/beam_asm.erl
@@ -67,7 +67,7 @@ assemble({Mod,Exp0,Attr0,Asm0,NumLabels}, ExtraChunks, CompileInfo, CompilerOpts
Dict2 = shared_fun_wrappers(CompilerOpts, Dict1),
NumFuncs = length(Asm0),
{Asm,Attr} = on_load(Asm0, Attr0),
- Exp = cerl_sets:from_list(Exp0),
+ Exp = sets:from_list(Exp0, [{version, 2}]),
{Code,Dict} = assemble_1(Asm, Exp, Dict2, []),
build_file(Code, Attr, Dict, NumLabels, NumFuncs,
ExtraChunks, CompileInfo, CompilerOpts).
@@ -112,7 +112,7 @@ insert_on_load_instruction(Is0, Entry) ->
Bef ++ [El,on_load|Is].
assemble_1([{function,Name,Arity,Entry,Asm}|T], Exp, Dict0, Acc) ->
- Dict1 = case cerl_sets:is_element({Name,Arity}, Exp) of
+ Dict1 = case sets:is_element({Name,Arity}, Exp) of
true ->
beam_dict:export(Name, Arity, Entry, Dict0);
false ->
diff --git a/lib/compiler/src/beam_clean.erl b/lib/compiler/src/beam_clean.erl
index 67ac0a6201..643cc1c386 100644
--- a/lib/compiler/src/beam_clean.erl
+++ b/lib/compiler/src/beam_clean.erl
@@ -31,7 +31,7 @@ module({Mod,Exp,Attr,Fs0,_}, Opts) ->
Order = [Lbl || {function,_,_,Lbl,_} <- Fs0],
All = maps:from_list([{Lbl,Func} || {function,_,_,Lbl,_}=Func <- Fs0]),
WorkList = rootset(Fs0, Exp, Attr),
- Used = find_all_used(WorkList, All, cerl_sets:from_list(WorkList)),
+ Used = find_all_used(WorkList, All, sets:from_list(WorkList, [{version, 2}])),
Fs1 = remove_unused(Order, Used, All),
{Fs2,Lc} = clean_labels(Fs1),
Fs3 = fix_swap(Fs2, Opts),
@@ -54,7 +54,7 @@ rootset(Fs, Root0, Attr) ->
%% Remove the unused functions.
remove_unused([F|Fs], Used, All) ->
- case cerl_sets:is_element(F, Used) of
+ case sets:is_element(F, Used) of
false -> remove_unused(Fs, Used, All);
true -> [map_get(F, All)|remove_unused(Fs, Used, All)]
end;
@@ -79,9 +79,9 @@ update_work_list([_|Is], Sets) ->
update_work_list([], Sets) -> Sets.
add_to_work_list(F, {Fs,Used}=Sets) ->
- case cerl_sets:is_element(F, Used) of
+ case sets:is_element(F, Used) of
true -> Sets;
- false -> {[F|Fs],cerl_sets:add_element(F, Used)}
+ false -> {[F|Fs],sets:add_element(F, Used)}
end.
diff --git a/lib/compiler/src/beam_digraph.erl b/lib/compiler/src/beam_digraph.erl
index 800fcf4c22..56d86990e3 100644
--- a/lib/compiler/src/beam_digraph.erl
+++ b/lib/compiler/src/beam_digraph.erl
@@ -134,7 +134,7 @@ in_neighbours(#dg{in_es=InEsMap}, V) ->
-spec is_path(graph(), vertex(), vertex()) -> boolean().
is_path(G, From, To) ->
- Seen = cerl_sets:new(),
+ Seen = sets:new([{version, 2}]),
try
_ = is_path_1([From], To, G, Seen),
false
@@ -146,11 +146,11 @@ is_path(G, From, To) ->
is_path_1([To|_], To, _G, _Seen) ->
throw(true);
is_path_1([V|Vs], To, G, Seen0) ->
- case cerl_sets:is_element(V, Seen0) of
+ case sets:is_element(V, Seen0) of
true ->
is_path_1(Vs, To, G, Seen0);
false ->
- Seen1 = cerl_sets:add_element(V, Seen0),
+ Seen1 = sets:add_element(V, Seen0),
Successors = out_neighbours(G, V),
Seen = is_path_1(Successors, To, G, Seen1),
is_path_1(Vs, To, G, Seen)
@@ -180,16 +180,16 @@ vertices(#dg{vs=Vs}) ->
-spec reverse_postorder(graph(), [vertex()]) -> [vertex()].
reverse_postorder(G, Vs) ->
- Seen = cerl_sets:new(),
+ Seen = sets:new([{version, 2}]),
{RPO, _} = reverse_postorder_1(Vs, G, Seen, []),
RPO.
reverse_postorder_1([V|Vs], G, Seen0, Acc0) ->
- case cerl_sets:is_element(V, Seen0) of
+ case sets:is_element(V, Seen0) of
true ->
reverse_postorder_1(Vs, G, Seen0, Acc0);
false ->
- Seen1 = cerl_sets:add_element(V, Seen0),
+ Seen1 = sets:add_element(V, Seen0),
Successors = out_neighbours(G, V),
{Acc,Seen} = reverse_postorder_1(Successors, G, Seen1, Acc0),
reverse_postorder_1(Vs, G, Seen, [V|Acc])
diff --git a/lib/compiler/src/beam_jump.erl b/lib/compiler/src/beam_jump.erl
index 0cb9c12f12..8738ce718f 100644
--- a/lib/compiler/src/beam_jump.erl
+++ b/lib/compiler/src/beam_jump.erl
@@ -548,7 +548,7 @@ extract_seq_1(_, _) -> no.
{
entry :: beam_asm:label(), %Entry label (must not be moved).
replace :: #{beam_asm:label() := beam_asm:label()}, %Labels to replace.
- labels :: cerl_sets:set() %Set of referenced labels.
+ labels :: sets:set() %Set of referenced labels.
}).
opt(Is0, CLabel) ->
@@ -692,7 +692,7 @@ skip_unreachable([], Acc, St) ->
%% Add one or more label to the set of used labels.
-label_used({f,L}, St) -> St#st{labels=cerl_sets:add_element(L,St#st.labels)};
+label_used({f,L}, St) -> St#st{labels=sets:add_element(L,St#st.labels)};
label_used([H|T], St0) -> label_used(T, label_used(H, St0));
label_used([], St) -> St;
label_used(_Other, St) -> St.
@@ -700,7 +700,7 @@ label_used(_Other, St) -> St.
%% Test if label is used.
is_label_used(L, St) ->
- cerl_sets:is_element(L, St#st.labels).
+ sets:is_element(L, St#st.labels).
%% is_unreachable_after(Instruction) -> boolean()
%% Test whether the code after Instruction is unreachable.
@@ -739,7 +739,7 @@ remove_unused_labels(Is) ->
rem_unused(Is, Used, []).
rem_unused([{label,Lbl}=I|Is0], Used, [Prev|_]=Acc) ->
- case cerl_sets:is_element(Lbl, Used) of
+ case sets:is_element(Lbl, Used) of
false ->
Is = case is_unreachable_after(Prev) of
true -> drop_upto_label(Is0);
@@ -761,7 +761,7 @@ initial_labels([{line,_}|Is], Acc) ->
initial_labels([{label,Lbl}|Is], Acc) ->
initial_labels(Is, [Lbl|Acc]);
initial_labels([{func_info,_,_,_},{label,Lbl}|_], Acc) ->
- cerl_sets:from_list([Lbl|Acc]).
+ sets:from_list([Lbl|Acc], [{version, 2}]).
drop_upto_label([{label,_}|_]=Is) -> Is;
drop_upto_label([_|Is]) -> drop_upto_label(Is);
@@ -812,13 +812,13 @@ ulbl(I, Used) ->
[] ->
Used;
[Lbl] ->
- cerl_sets:add_element(Lbl, Used);
+ sets:add_element(Lbl, Used);
[_|_]=L ->
ulbl_list(L, Used)
end.
ulbl_list([L|Ls], Used) ->
- ulbl_list(Ls, cerl_sets:add_element(L, Used));
+ ulbl_list(Ls, sets:add_element(L, Used));
ulbl_list([], Used) -> Used.
-spec instr_labels(Instruction) -> Labels when
diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index 76303b34cb..0991c584fb 100644
--- a/lib/compiler/src/beam_ssa.erl
+++ b/lib/compiler/src/beam_ssa.erl
@@ -356,7 +356,7 @@ def(Ls, Blocks) ->
def_unused(Ls, Unused, Blocks) ->
Blks = [map_get(L, Blocks) || L <- Ls],
- Preds = cerl_sets:from_list(Ls),
+ Preds = sets:from_list(Ls, [{version, 2}]),
def_unused_1(Blks, Preds, [], Unused).
%% dominators(Labels, BlockMap) -> {Dominators,Numbering}.
@@ -481,7 +481,7 @@ fold_blocks(Fun, Labels, Acc0, Blocks) ->
Linear :: [{label(),b_blk()}].
linearize(Blocks) ->
- Seen = cerl_sets:new(),
+ Seen = sets:new([{version, 2}]),
{Linear0,_} = linearize_1([0], Blocks, Seen, []),
Linear = fix_phis(Linear0, #{}),
Linear.
@@ -499,7 +499,7 @@ rpo(Blocks) ->
Labels :: [label()].
rpo(From, Blocks) ->
- Seen = cerl_sets:new(),
+ Seen = sets:new([{version, 2}]),
{Ls,_} = rpo_1(From, Blocks, Seen, []),
Ls.
@@ -523,7 +523,7 @@ between(From, To, Preds, Blocks) ->
%% gathering once seen since we're only interested in the blocks in between.
%% Uninteresting blocks can still be added if `From` doesn't dominate `To`,
%% but that has no effect on the final result.
- Filter = between_make_filter([To], Preds, cerl_sets:from_list([From])),
+ Filter = between_make_filter([To], Preds, sets:from_list([From], [{version, 2}])),
{Paths, _} = between_rpo([From], Blocks, Filter, []),
Paths.
@@ -534,7 +534,7 @@ between(From, To, Preds, Blocks) ->
rename_vars(Rename, Labels, Blocks) when is_list(Rename) ->
rename_vars(maps:from_list(Rename), Labels, Blocks);
rename_vars(Rename, Labels, Blocks) when is_map(Rename)->
- Preds = cerl_sets:from_list(Labels),
+ Preds = sets:from_list(Labels, [{version, 2}]),
F = fun(#b_set{op=phi,args=Args0}=Set) ->
Args = rename_phi_vars(Args0, Preds, Rename),
normalize(Set#b_set{args=Args});
@@ -580,7 +580,7 @@ trim_unreachable(Blocks) when is_map(Blocks) ->
%% Could perhaps be optimized if there is any need.
maps:from_list(linearize(Blocks));
trim_unreachable([_|_]=Blocks) ->
- trim_unreachable_1(Blocks, cerl_sets:from_list([0])).
+ trim_unreachable_1(Blocks, sets:from_list([0], [{version, 2}])).
-spec used(b_blk() | b_set() | terminator()) -> [var_name()].
@@ -667,7 +667,7 @@ def_unused_is([#b_set{op=phi,dst=Dst,args=Args}|Is],
%% We must be careful to only include variables that will
%% be used when arriving from one of the predecessor blocks
%% in Preds.
- Unused1 = [V || {#b_var{}=V,L} <- Args, cerl_sets:is_element(L, Preds)],
+ Unused1 = [V || {#b_var{}=V,L} <- Args, sets:is_element(L, Preds)],
Unused = ordsets:subtract(Unused0, ordsets:from_list(Unused1)),
def_unused_is(Is, Preds, Def, Unused);
def_unused_is([#b_set{dst=Dst}=I|Is], Preds, Def0, Unused0) ->
@@ -753,11 +753,11 @@ flatmapfold_instrs_1([], _, Blocks, Acc) ->
{Blocks,Acc}.
linearize_1([L|Ls], Blocks, Seen0, Acc0) ->
- case cerl_sets:is_element(L, Seen0) of
+ case sets:is_element(L, Seen0) of
true ->
linearize_1(Ls, Blocks, Seen0, Acc0);
false ->
- Seen1 = cerl_sets:add_element(L, Seen0),
+ Seen1 = sets:add_element(L, Seen0),
Block = map_get(L, Blocks),
Successors = successors(Block),
{Acc,Seen} = linearize_1(Successors, Blocks, Seen1, Acc0),
@@ -795,7 +795,7 @@ is_successor(L, Pred, S) ->
trim_unreachable_1([{L,Blk0}|Bs], Seen0) ->
Blk = trim_phis(Blk0, Seen0),
- case cerl_sets:is_element(L, Seen0) of
+ case sets:is_element(L, Seen0) of
false ->
trim_unreachable_1(Bs, Seen0);
true ->
@@ -803,7 +803,7 @@ trim_unreachable_1([{L,Blk0}|Bs], Seen0) ->
[] ->
[{L,Blk}|trim_unreachable_1(Bs, Seen0)];
[_|_]=Successors ->
- Seen = cerl_sets:union(Seen0, cerl_sets:from_list(Successors)),
+ Seen = sets:union(Seen0, sets:from_list(Successors, [{version, 2}])),
[{L,Blk}|trim_unreachable_1(Bs, Seen)]
end
end;
@@ -815,17 +815,17 @@ trim_phis(#b_blk{is=[#b_set{op=phi}|_]=Is0}=Blk, Seen) ->
trim_phis(Blk, _Seen) -> Blk.
trim_phis_1([#b_set{op=phi,args=Args0}=I|Is], Seen) ->
- Args = [P || {_,L}=P <- Args0, cerl_sets:is_element(L, Seen)],
+ Args = [P || {_,L}=P <- Args0, sets:is_element(L, Seen)],
[I#b_set{args=Args}|trim_phis_1(Is, Seen)];
trim_phis_1(Is, _Seen) -> Is.
between_make_filter([L | Ls], Preds, Acc0) ->
- case cerl_sets:is_element(L, Acc0) of
+ case sets:is_element(L, Acc0) of
true ->
between_make_filter(Ls, Preds, Acc0);
false ->
Next = map_get(L, Preds),
- Acc1 = cerl_sets:add_element(L, Acc0),
+ Acc1 = sets:add_element(L, Acc0),
Acc = between_make_filter(Next, Preds, Acc1),
between_make_filter(Ls, Preds, Acc)
@@ -834,10 +834,10 @@ between_make_filter([], _Preds, Acc) ->
Acc.
between_rpo([L | Ls], Blocks, Filter0, Acc0) ->
- case cerl_sets:is_element(L, Filter0) of
+ case sets:is_element(L, Filter0) of
true ->
Block = map_get(L, Blocks),
- Filter1 = cerl_sets:del_element(L, Filter0),
+ Filter1 = sets:del_element(L, Filter0),
Successors = successors(Block),
{Acc, Filter} = between_rpo(Successors, Blocks, Filter1, Acc0),
@@ -849,12 +849,12 @@ between_rpo([], _, Filter, Acc) ->
{Acc, Filter}.
rpo_1([L|Ls], Blocks, Seen0, Acc0) ->
- case cerl_sets:is_element(L, Seen0) of
+ case sets:is_element(L, Seen0) of
true ->
rpo_1(Ls, Blocks, Seen0, Acc0);
false ->
Block = map_get(L, Blocks),
- Seen1 = cerl_sets:add_element(L, Seen0),
+ Seen1 = sets:add_element(L, Seen0),
Successors = successors(Block),
{Acc,Seen} = rpo_1(Successors, Blocks, Seen1, Acc0),
rpo_1(Ls, Blocks, Seen, [L|Acc])
@@ -874,7 +874,7 @@ rename_var(#b_remote{mod=Mod0,name=Name0}=Remote, Rename) ->
rename_var(Old, _) -> Old.
rename_phi_vars([{Var,L}|As], Preds, Ren) ->
- case cerl_sets:is_element(L, Preds) of
+ case sets:is_element(L, Preds) of
true ->
[{rename_var(Var, Ren),L}|rename_phi_vars(As, Preds, Ren)];
false ->
diff --git a/lib/compiler/src/beam_ssa_bool.erl b/lib/compiler/src/beam_ssa_bool.erl
index b3b41e68c3..1404d8197f 100644
--- a/lib/compiler/src/beam_ssa_bool.erl
+++ b/lib/compiler/src/beam_ssa_bool.erl
@@ -208,7 +208,7 @@ pre_opt(Blocks, Count) ->
Sub = maps:remove(uses, Sub1),
%% Now do the actual optimizations.
- Reached = cerl_sets:from_list([hd(Top)]),
+ Reached = sets:from_list([hd(Top)], [{version, 2}]),
pre_opt(Top, Sub, Reached, Count, Blocks).
-spec get_phi_info(Ls, Blocks, Sub0) -> Sub when
@@ -288,7 +288,7 @@ get_phi_info_single_use(Var, Sub) ->
-spec pre_opt(Ls, Sub, Reached, Count0, Blocks0) -> {Blocks,Count} when
Ls :: [beam_ssa:label()],
- Reached :: cerl_sets:set(beam_ssa:label()),
+ Reached :: sets:set(beam_ssa:label()),
Count0 :: beam_ssa:label(),
Blocks0 :: beam_ssa:block_map(),
Sub :: pre_sub_map(),
@@ -296,7 +296,7 @@ get_phi_info_single_use(Var, Sub) ->
Blocks :: beam_ssa:block_map().
pre_opt([L|Ls], Sub0, Reached0, Count0, Blocks) ->
- case cerl_sets:is_element(L, Reached0) of
+ case sets:is_element(L, Reached0) of
false ->
%% This block will never be reached.
pre_opt(Ls, Sub0, Reached0, Count0, maps:remove(L, Blocks));
@@ -313,14 +313,14 @@ pre_opt([L|Ls], Sub0, Reached0, Count0, Blocks) ->
Br = beam_ssa:normalize(Br0#b_br{bool=Bool}),
Blk = Blk0#b_blk{is=Is++[Test],last=Br},
Successors = beam_ssa:successors(Blk),
- Reached = cerl_sets:union(Reached0,
- cerl_sets:from_list(Successors)),
+ Reached = sets:union(Reached0,
+ sets:from_list(Successors, [{version, 2}])),
pre_opt(Ls, Sub, Reached, Count, Blocks#{L:=Blk});
Last ->
Blk = Blk0#b_blk{is=Is,last=Last},
Successors = beam_ssa:successors(Blk),
- Reached = cerl_sets:union(Reached0,
- cerl_sets:from_list(Successors)),
+ Reached = sets:union(Reached0,
+ sets:from_list(Successors, [{version, 2}])),
pre_opt(Ls, Sub, Reached, Count0, Blocks#{L:=Blk})
end
end;
@@ -329,7 +329,7 @@ pre_opt([], _, _, Count, Blocks) ->
pre_opt_is([#b_set{op=phi,dst=Dst,args=Args0}=I0|Is], Reached, Sub0, Acc) ->
Args1 = [{Val,From} || {Val,From} <- Args0,
- cerl_sets:is_element(From, Reached)],
+ sets:is_element(From, Reached)],
Args = sub_args(Args1, Sub0),
case all_same(Args) of
true ->
@@ -751,7 +751,7 @@ split_dom_block_is([], PreAcc) ->
collect_digraph_blocks(FirstL, LastL, #b_br{succ=Succ,fail=Fail}, Blocks) ->
Ws = gb_sets:singleton(FirstL),
- Seen = cerl_sets:from_list([Succ,Fail]),
+ Seen = sets:from_list([Succ,Fail], [{version, 2}]),
collect_digraph_blocks(Ws, LastL, Blocks, Seen, []).
collect_digraph_blocks(Ws0, LastL, Blocks, Seen0, Acc0) ->
@@ -760,7 +760,7 @@ collect_digraph_blocks(Ws0, LastL, Blocks, Seen0, Acc0) ->
Acc0;
false ->
{L,Ws1} = gb_sets:take_smallest(Ws0),
- Seen = cerl_sets:add_element(L, Seen0),
+ Seen = sets:add_element(L, Seen0),
Blk = map_get(L, Blocks),
Acc = [{L,Blk}|Acc0],
Ws = cdb_update_workset(L, Blk, LastL, Seen, Ws1),
@@ -774,7 +774,7 @@ cdb_update_workset(_L, Blk, _LastL, Seen, Ws) ->
cdb_update_workset(Successors, Seen, Ws).
cdb_update_workset([L|Ls], Seen, Ws) ->
- case cerl_sets:is_element(L, Seen) of
+ case sets:is_element(L, Seen) of
true ->
cdb_update_workset(Ls, Seen, Ws);
false ->
@@ -1509,16 +1509,16 @@ join_inits_1([], VarMap) ->
%%%
digraph_to_ssa(Ls, G, Blocks0) ->
- Seen = cerl_sets:new(),
+ Seen = sets:new([{version, 2}]),
{Blocks,_} = digraph_to_ssa(Ls, G, Blocks0, Seen),
Blocks.
digraph_to_ssa([L|Ls], G, Blocks0, Seen0) ->
- Seen1 = cerl_sets:add_element(L, Seen0),
+ Seen1 = sets:add_element(L, Seen0),
{Blk,Successors0} = digraph_to_ssa_blk(L, G, Blocks0, []),
Blocks1 = Blocks0#{L=>Blk},
Successors = [S || S <- Successors0,
- not cerl_sets:is_element(S, Seen1)],
+ not sets:is_element(S, Seen1)],
{Blocks,Seen} = digraph_to_ssa(Successors, G, Blocks1, Seen1),
digraph_to_ssa(Ls, G, Blocks, Seen);
digraph_to_ssa([], _G, Blocks, Seen) ->
@@ -1629,16 +1629,16 @@ del_out_edges(V, G) ->
beam_digraph:del_edges(G, beam_digraph:out_edges(G, V)).
covered(From, To, G) ->
- Seen0 = cerl_sets:new(),
+ Seen0 = sets:new([{version, 2}]),
{yes,Seen} = covered_1(From, To, G, Seen0),
- cerl_sets:to_list(Seen).
+ sets:to_list(Seen).
covered_1(To, To, _G, Seen) ->
{yes,Seen};
covered_1(From, To, G, Seen0) ->
Vs0 = beam_digraph:out_neighbours(G, From),
- Vs = [V || V <- Vs0, not cerl_sets:is_element(V, Seen0)],
- Seen = cerl_sets:union(cerl_sets:from_list(Vs), Seen0),
+ Vs = [V || V <- Vs0, not sets:is_element(V, Seen0)],
+ Seen = sets:union(sets:from_list(Vs, [{version, 2}]), Seen0),
case Vs of
[] ->
no;
diff --git a/lib/compiler/src/beam_ssa_dead.erl b/lib/compiler/src/beam_ssa_dead.erl
index a62da9dac2..7af48c0860 100644
--- a/lib/compiler/src/beam_ssa_dead.erl
+++ b/lib/compiler/src/beam_ssa_dead.erl
@@ -30,7 +30,7 @@
-import(lists, [append/1,keymember/3,last/1,member/2,
reverse/1,sort/1,takewhile/2]).
--type used_vars() :: #{beam_ssa:label():=cerl_sets:set(beam_ssa:var_name())}.
+-type used_vars() :: #{beam_ssa:label():=sets:set(beam_ssa:var_name())}.
-type basic_type_test() :: atom() | {'is_tagged_tuple',pos_integer(),atom()}.
-type type_test() :: basic_type_test() | {'not',basic_type_test()}.
@@ -177,7 +177,7 @@ shortcut(L, _From, Bs, #st{rel_op=none,target=one_way}) when map_size(Bs) =:= 0
%% is `one_way`, it implies the From block has a two-way `br` terminator.
#b_br{bool=#b_literal{val=true},succ=L,fail=L};
shortcut(L, From, Bs, St) ->
- shortcut_1(L, From, Bs, cerl_sets:new(), St).
+ shortcut_1(L, From, Bs, sets:new([{version, 2}]), St).
shortcut_1(L, From, Bs0, UnsetVars0, St) ->
case shortcut_2(L, From, Bs0, UnsetVars0, St) of
@@ -195,7 +195,7 @@ shortcut_1(L, From, Bs0, UnsetVars0, St) ->
%% Try to shortcut this block, branching to a successor.
shortcut_2(L, From, Bs, UnsetVars, St) ->
- case cerl_sets:size(UnsetVars) of
+ case sets:size(UnsetVars) of
SetSize when SetSize > 64 ->
%% This is an heuristic to limit the search for a forced label
%% before it drastically slows down the compiler. Experiments
@@ -383,7 +383,7 @@ update_unset_vars(L, Is, Br, UnsetVars, #st{skippable=Skippable}) ->
%% Some variables defined in this block are used by
%% successors. We must update the set of unset variables.
SetInThisBlock = [V || #b_set{dst=V} <- Is],
- cerl_sets:union(UnsetVars, cerl_sets:from_list(SetInThisBlock))
+ sets:union(UnsetVars, sets:from_list(SetInThisBlock, [{version, 2}]))
end.
shortcut_two_way(#b_br{succ=Succ,fail=Fail}, From, Bs0, UnsetVars0, St0) ->
@@ -412,14 +412,14 @@ is_br_safe(UnsetVars, Br, #st{us=Us}=St) ->
%% A two-way branch never branches to a phi node, so there
%% is no need to check for phi nodes here.
- not cerl_sets:is_element(V, UnsetVars) andalso
- cerl_sets:is_disjoint(Used0, UnsetVars) andalso
- cerl_sets:is_disjoint(Used1, UnsetVars);
+ not sets:is_element(V, UnsetVars) andalso
+ sets:is_disjoint(Used0, UnsetVars) andalso
+ sets:is_disjoint(Used1, UnsetVars);
#b_br{succ=Same,fail=Same} ->
%% An unconditional branch must not jump to
%% a phi node.
not is_forbidden(Same, St) andalso
- cerl_sets:is_disjoint(map_get(Same, Us), UnsetVars)
+ sets:is_disjoint(map_get(Same, Us), UnsetVars)
end.
is_forbidden(L, St) ->
@@ -546,7 +546,7 @@ eval_switch_1([], _Arg, _PrevOp, Fail) ->
Fail.
bind_var_if_used(L, Var, Val, #st{us=Us}) ->
- case cerl_sets:is_element(Var, map_get(L, Us)) of
+ case sets:is_element(Var, map_get(L, Us)) of
true -> #{Var=>Val};
false -> #{}
end.
@@ -1057,7 +1057,7 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) ->
%% shortcut_opt/1.
Successors = beam_ssa:successors(Blk),
- Used0 = used_vars_succ(Successors, L, UsedVars0, cerl_sets:new()),
+ Used0 = used_vars_succ(Successors, L, UsedVars0, sets:new([{version, 2}])),
Used = used_vars_blk(Blk, Used0),
UsedVars = used_vars_phis(Is, L, Used, UsedVars0),
@@ -1068,8 +1068,8 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) ->
%% shortcut_opt/1.
Defined0 = [Def || #b_set{dst=Def} <- Is],
- Defined = cerl_sets:from_list(Defined0),
- MaySkip = cerl_sets:is_disjoint(Defined, Used0),
+ Defined = sets:from_list(Defined0, [{version, 2}]),
+ MaySkip = sets:is_disjoint(Defined, Used0),
case MaySkip of
true ->
Skip = Skip0#{L=>true},
@@ -1086,11 +1086,11 @@ used_vars_succ([S|Ss], L, LiveMap, Live0) ->
#{Key:=Live} ->
%% The successor has a phi node, and the value for
%% this block in the phi node is a variable.
- used_vars_succ(Ss, L, LiveMap, cerl_sets:union(Live, Live0));
+ used_vars_succ(Ss, L, LiveMap, sets:union(Live, Live0));
#{S:=Live} ->
%% No phi node in the successor, or the value for
%% this block in the phi node is a literal.
- used_vars_succ(Ss, L, LiveMap, cerl_sets:union(Live, Live0));
+ used_vars_succ(Ss, L, LiveMap, sets:union(Live, Live0));
#{} ->
%% A peek_message block which has not been processed yet.
used_vars_succ(Ss, L, LiveMap, Live0)
@@ -1108,7 +1108,7 @@ used_vars_phis(Is, L, Live0, UsedVars0) ->
case [{P,V} || {#b_var{}=V,P} <- PhiArgs] of
[_|_]=PhiVars ->
PhiLive0 = rel2fam(PhiVars),
- PhiLive = [{{L,P},cerl_sets:union(cerl_sets:from_list(Vs), Live0)} ||
+ PhiLive = [{{L,P},sets:union(sets:from_list(Vs, [{version, 2}]), Live0)} ||
{P,Vs} <- PhiLive0],
maps:merge(UsedVars, maps:from_list(PhiLive));
[] ->
@@ -1118,14 +1118,14 @@ used_vars_phis(Is, L, Live0, UsedVars0) ->
end.
used_vars_blk(#b_blk{is=Is,last=Last}, Used0) ->
- Used = cerl_sets:union(Used0, cerl_sets:from_list(beam_ssa:used(Last))),
+ Used = sets:union(Used0, sets:from_list(beam_ssa:used(Last), [{version, 2}])),
used_vars_is(reverse(Is), Used).
used_vars_is([#b_set{op=phi}|Is], Used) ->
used_vars_is(Is, Used);
used_vars_is([#b_set{dst=Dst}=I|Is], Used0) ->
- Used1 = cerl_sets:union(Used0, cerl_sets:from_list(beam_ssa:used(I))),
- Used = cerl_sets:del_element(Dst, Used1),
+ Used1 = sets:union(Used0, sets:from_list(beam_ssa:used(I), [{version, 2}])),
+ Used = sets:del_element(Dst, Used1),
used_vars_is(Is, Used);
used_vars_is([], Used) ->
Used.
diff --git a/lib/compiler/src/beam_ssa_funs.erl b/lib/compiler/src/beam_ssa_funs.erl
index 394a631708..2b2feb5656 100644
--- a/lib/compiler/src/beam_ssa_funs.erl
+++ b/lib/compiler/src/beam_ssa_funs.erl
@@ -134,17 +134,17 @@ lfo_optimize_is([], _LFuns, _Trampolines) ->
[].
lfo_short_circuit(Call, Trampolines) ->
- lfo_short_circuit(Call, Trampolines, cerl_sets:new()).
+ lfo_short_circuit(Call, Trampolines, sets:new([{version, 2}])).
lfo_short_circuit(Call, Trampolines, Seen0) ->
%% Beware of infinite loops! Get out if this call has been seen before.
- case cerl_sets:is_element(Call, Seen0) of
+ case sets:is_element(Call, Seen0) of
true ->
Call;
false ->
case Trampolines of
#{Call := Other} ->
- Seen = cerl_sets:add_element(Call, Seen0),
+ Seen = sets:add_element(Call, Seen0),
lfo_short_circuit(Other, Trampolines, Seen);
#{} ->
Call
diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index 0b14e6eda3..72eb8ea3f1 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -96,7 +96,7 @@ fixpoint(_FuncIds, _Order, _Passes, StMap, FuncDb, 0) ->
fixpoint(FuncIds0, Order0, Passes, StMap0, FuncDb0, N) ->
{StMap, FuncDb} = phase(FuncIds0, Passes, StMap0, FuncDb0),
Repeat = changed(FuncIds0, FuncDb0, FuncDb, StMap0, StMap),
- case cerl_sets:size(Repeat) of
+ case sets:size(Repeat) of
0 ->
%% No change. Fixpoint reached.
{StMap, FuncDb};
@@ -106,7 +106,7 @@ fixpoint(FuncIds0, Order0, Passes, StMap0, FuncDb0, N) ->
%% information.
{OrderA, OrderB} = Order0,
Order = {OrderB, OrderA},
- FuncIds = [Id || Id <- OrderA, cerl_sets:is_element(Id, Repeat)],
+ FuncIds = [Id || Id <- OrderA, sets:is_element(Id, Repeat)],
fixpoint(FuncIds, Order, Passes, StMap, FuncDb, N - 1)
end.
@@ -133,7 +133,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) ->
%% have been updated for functions not included in the previous run.
F = fun(Id, A) ->
- case cerl_sets:is_element(Id, A) of
+ case sets:is_element(Id, A) of
true ->
A;
false ->
@@ -162,7 +162,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) ->
end
end
end,
- Ids = foldl(F, cerl_sets:new(), maps:keys(FuncDb)),
+ Ids = foldl(F, sets:new([{version, 2}]), maps:keys(FuncDb)),
%% From all functions that were optimized in the previous run,
%% find the functions that had any change in the SSA code. Those
@@ -175,7 +175,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) ->
%% optimization turned off (and thus not included in FuncDb).
foldl(fun(Id, A) ->
- case cerl_sets:is_element(Id, A) of
+ case sets:is_element(Id, A) of
true ->
%% Already scheduled for another optimization.
%% No need to compare the SSA code.
@@ -184,17 +184,17 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) ->
%% Compare the SSA code before and after optimization.
case {map_get(Id, StMap0),map_get(Id, StMap)} of
{Same,Same} -> A;
- {_,_} -> cerl_sets:add_element(Id, A)
+ {_,_} -> sets:add_element(Id, A)
end
end
end, Ids, PrevIds).
add_changed([Id|Ids], Opts, FuncDb, S0) when is_map_key(Id, FuncDb) ->
- case cerl_sets:is_element(Id, S0) of
+ case sets:is_element(Id, S0) of
true ->
add_changed(Ids, Opts, FuncDb, S0);
false ->
- S1 = cerl_sets:add_element(Id, S0),
+ S1 = sets:add_element(Id, S0),
#func_info{in=In,out=Out} = map_get(Id, FuncDb),
S2 = case member(callers, Opts) of
true -> add_changed(In, Opts, FuncDb, S1);
@@ -417,16 +417,16 @@ get_call_order_po(StMap, FuncDb) ->
gco_po(FuncDb) ->
All = sort(maps:keys(FuncDb)),
- {RPO,_} = gco_rpo(All, FuncDb, cerl_sets:new(), []),
+ {RPO,_} = gco_rpo(All, FuncDb, sets:new([{version, 2}]), []),
reverse(RPO).
gco_rpo([Id|Ids], FuncDb, Seen0, Acc0) ->
- case cerl_sets:is_element(Id, Seen0) of
+ case sets:is_element(Id, Seen0) of
true ->
gco_rpo(Ids, FuncDb, Seen0, Acc0);
false ->
#func_info{out=Successors} = map_get(Id, FuncDb),
- Seen1 = cerl_sets:add_element(Id, Seen0),
+ Seen1 = sets:add_element(Id, Seen0),
{Acc,Seen} = gco_rpo(Successors, FuncDb, Seen1, Acc0),
gco_rpo(Ids, FuncDb, Seen, [Id|Acc])
end;
@@ -1037,7 +1037,7 @@ cse_suitable(#b_set{}) -> false.
-record(fs,
{s=undefined :: 'undefined' | 'cleared',
regs=#{} :: #{beam_ssa:b_var():=beam_ssa:b_var()},
- vars=cerl_sets:new() :: cerl_sets:set(),
+ vars=sets:new([{version, 2}]) :: sets:set(),
fail=none :: 'none' | beam_ssa:label(),
non_guards :: gb_sets:set(beam_ssa:label()),
bs :: beam_ssa:block_map()
@@ -1213,7 +1213,7 @@ float_make_op(#b_set{op={bif,Op},dst=Dst,args=As0,anno=Anno}=I0,
{Fr,Count2} = new_reg('@fr', Count1),
FrDst = #b_var{name=Fr},
I = I0#b_set{op={float,Op},dst=FrDst,args=As},
- Vs = cerl_sets:add_element(Dst, Vs0),
+ Vs = sets:add_element(Dst, Vs0),
Rs = Rs1#{Dst=>FrDst},
Is = append(Is0) ++ [I],
case S of
@@ -1297,7 +1297,7 @@ ssa_opt_live({#opt_st{ssa=Linear0}=St, FuncDb}) ->
live_opt([{L,Blk0}|Bs], LiveMap0, Blocks) ->
Blk1 = beam_ssa_share:block(Blk0, Blocks),
Successors = beam_ssa:successors(Blk1),
- Live0 = live_opt_succ(Successors, L, LiveMap0, cerl_sets:new()),
+ Live0 = live_opt_succ(Successors, L, LiveMap0, sets:new([{version, 2}])),
{Blk,Live} = live_opt_blk(Blk1, Live0),
LiveMap = live_opt_phis(Blk#b_blk.is, L, Live, LiveMap0),
live_opt(Bs, LiveMap, Blocks#{L:=Blk});
@@ -1308,11 +1308,11 @@ live_opt_succ([S|Ss], L, LiveMap, Live0) ->
#{{S,L}:=Live} ->
%% The successor has a phi node, and the value for
%% this block in the phi node is a variable.
- live_opt_succ(Ss, L, LiveMap, cerl_sets:union(Live0, Live));
+ live_opt_succ(Ss, L, LiveMap, sets:union(Live0, Live));
#{S:=Live} ->
%% No phi node in the successor, or the value for
%% this block in the phi node is a literal.
- live_opt_succ(Ss, L, LiveMap, cerl_sets:union(Live0, Live));
+ live_opt_succ(Ss, L, LiveMap, sets:union(Live0, Live));
#{} ->
%% A peek_message block which has not been processed yet.
live_opt_succ(Ss, L, LiveMap, Live0)
@@ -1330,7 +1330,7 @@ live_opt_phis(Is, L, Live0, LiveMap0) ->
case [{P,V} || {#b_var{}=V,P} <- PhiArgs] of
[_|_]=PhiVars ->
PhiLive0 = rel2fam(PhiVars),
- PhiLive = [{{L,P},cerl_sets:union(cerl_sets:from_list(Vs), Live0)} ||
+ PhiLive = [{{L,P},sets:union(sets:from_list(Vs, [{version, 2}]), Live0)} ||
{P,Vs} <- PhiLive0],
maps:merge(LiveMap, maps:from_list(PhiLive));
[] ->
@@ -1340,13 +1340,13 @@ live_opt_phis(Is, L, Live0, LiveMap0) ->
end.
live_opt_blk(#b_blk{is=Is0,last=Last}=Blk, Live0) ->
- Live1 = cerl_sets:union(Live0, cerl_sets:from_list(beam_ssa:used(Last))),
+ Live1 = sets:union(Live0, sets:from_list(beam_ssa:used(Last), [{version, 2}])),
{Is,Live} = live_opt_is(reverse(Is0), Live1, []),
{Blk#b_blk{is=Is},Live}.
live_opt_is([#b_set{op=phi,dst=Dst}=I|Is], Live0, Acc) ->
- Live = cerl_sets:del_element(Dst, Live0),
- case cerl_sets:is_element(Dst, Live0) of
+ Live = sets:del_element(Dst, Live0),
+ case sets:is_element(Dst, Live0) of
true ->
live_opt_is(Is, Live, [I|Acc]);
false ->
@@ -1355,10 +1355,10 @@ live_opt_is([#b_set{op=phi,dst=Dst}=I|Is], Live0, Acc) ->
live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI,
#b_set{op=Op,dst=Dst}=I0|Is],
Live0, Acc) ->
- case {cerl_sets:is_element(SuccDst, Live0),
- cerl_sets:is_element(Dst, Live0)} of
+ case {sets:is_element(SuccDst, Live0),
+ sets:is_element(Dst, Live0)} of
{true, true} ->
- Live = cerl_sets:del_element(SuccDst, Live0),
+ Live = sets:del_element(SuccDst, Live0),
live_opt_is([I0|Is], Live, [SuccI|Acc]);
{true, false} ->
%% The result of the instruction before {succeeded,guard} is
@@ -1378,8 +1378,8 @@ live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI,
I = I0#b_set{op=has_map_field,dst=SuccDst},
live_opt_is([I|Is], Live0, Acc);
_ ->
- Live1 = cerl_sets:del_element(SuccDst, Live0),
- Live = cerl_sets:add_element(Dst, Live1),
+ Live1 = sets:del_element(SuccDst, Live0),
+ Live = sets:add_element(Dst, Live1),
live_opt_is([I0|Is], Live, [SuccI|Acc])
end;
{false, true} ->
@@ -1388,19 +1388,19 @@ live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI,
live_opt_is(Is, Live0, Acc)
end;
live_opt_is([#b_set{dst=Dst}=I|Is], Live0, Acc) ->
- case cerl_sets:is_element(Dst, Live0) of
+ case sets:is_element(Dst, Live0) of
true ->
- LiveUsed = cerl_sets:from_list(beam_ssa:used(I)),
- Live1 = cerl_sets:union(Live0, LiveUsed),
- Live = cerl_sets:del_element(Dst, Live1),
+ LiveUsed = sets:from_list(beam_ssa:used(I), [{version, 2}]),
+ Live1 = sets:union(Live0, LiveUsed),
+ Live = sets:del_element(Dst, Live1),
live_opt_is(Is, Live, [I|Acc]);
false ->
case beam_ssa:no_side_effect(I) of
true ->
live_opt_is(Is, Live0, Acc);
false ->
- LiveUsed = cerl_sets:from_list(beam_ssa:used(I)),
- Live = cerl_sets:union(Live0, LiveUsed),
+ LiveUsed = sets:from_list(beam_ssa:used(I), [{version, 2}]),
+ Live = sets:union(Live0, LiveUsed),
live_opt_is(Is, Live, [I|Acc])
end
end;
@@ -1434,7 +1434,7 @@ ssa_opt_try({#opt_st{ssa=Linear0}=St, FuncDb}) ->
opt_try([{L,#b_blk{is=[#b_set{op=new_try_tag}],
last=Last}=Blk0}|Bs0]) ->
#b_br{succ=Succ,fail=Fail} = Last,
- Ws = cerl_sets:from_list([Succ,Fail]),
+ Ws = sets:from_list([Succ,Fail], [{version, 2}]),
try do_opt_try(Bs0, Ws) of
Bs ->
Blk = Blk0#b_blk{is=[],
@@ -1450,24 +1450,24 @@ opt_try([{L,Blk}|Bs]) ->
opt_try([]) -> [].
do_opt_try([{L,Blk}|Bs]=Bs0, Ws0) ->
- case cerl_sets:is_element(L, Ws0) of
+ case sets:is_element(L, Ws0) of
false ->
%% This block is not reachable from the block with the
%% `new_try_tag` instruction. Retain it. There is no
%% need to check it for safety.
- case cerl_sets:size(Ws0) of
+ case sets:size(Ws0) of
0 -> Bs0;
_ -> [{L,Blk}|do_opt_try(Bs, Ws0)]
end;
true ->
- Ws1 = cerl_sets:del_element(L, Ws0),
+ Ws1 = sets:del_element(L, Ws0),
#b_blk{is=Is0} = Blk,
case is_safe_without_try(Is0, []) of
{safe,Is} ->
%% This block does not execute any instructions
%% that would require a try. Analyze successors.
Successors = beam_ssa:successors(Blk),
- Ws = cerl_sets:union(cerl_sets:from_list(Successors),
+ Ws = sets:union(sets:from_list(Successors, [{version, 2}]),
Ws1),
[{L,Blk#b_blk{is=Is}}|do_opt_try(Bs, Ws)];
unsafe ->
@@ -1483,7 +1483,7 @@ do_opt_try([{L,Blk}|Bs]=Bs0, Ws0) ->
end
end;
do_opt_try([], Ws) ->
- 0 = cerl_sets:size(Ws), %Assertion.
+ 0 = sets:size(Ws), %Assertion.
[].
is_safe_without_try([#b_set{op=kill_try_tag}|Is], Acc) ->
@@ -1526,7 +1526,7 @@ is_safe_without_try([], Acc) ->
ssa_opt_bsm({#opt_st{ssa=Linear}=St, FuncDb}) ->
Extracted0 = bsm_extracted(Linear),
- Extracted = cerl_sets:from_list(Extracted0),
+ Extracted = sets:from_list(Extracted0, [{version, 2}]),
{St#opt_st{ssa=bsm_skip(Linear, Extracted)}, FuncDb}.
bsm_skip([{L,#b_blk{is=Is0}=Blk}|Bs0], Extracted) ->
@@ -1543,7 +1543,7 @@ bsm_skip_is([I0|Is], Extracted) ->
when T =/= float, T =/= string, T =/= skip ->
%% Note that it is never safe to skip matching
%% of floats, even if the size is known to be correct.
- I = case cerl_sets:is_element(Ctx, Extracted) of
+ I = case sets:is_element(Ctx, Extracted) of
true ->
I0;
false ->
diff --git a/lib/compiler/src/beam_ssa_pre_codegen.erl b/lib/compiler/src/beam_ssa_pre_codegen.erl
index 7fa018d7e8..6cda7b19de 100644
--- a/lib/compiler/src/beam_ssa_pre_codegen.erl
+++ b/lib/compiler/src/beam_ssa_pre_codegen.erl
@@ -1672,7 +1672,7 @@ find_loop_exit([_,_|_]=RmBlocks, Blocks) ->
%% remove_message blocks.
RPO = beam_ssa:rpo(Blocks),
{Dominators,_} = beam_ssa:dominators(RPO, Blocks),
- RmSet = cerl_sets:from_list(RmBlocks),
+ RmSet = sets:from_list(RmBlocks, [{version, 2}]),
RmRPO = beam_ssa:rpo(RmBlocks, Blocks),
find_loop_exit_1(RmRPO, RmSet, Dominators, Blocks);
find_loop_exit(_, _) ->
@@ -1686,7 +1686,7 @@ find_loop_exit_1([?EXCEPTION_BLOCK|Ls], RmSet, Dominators, Blocks) ->
find_loop_exit_1(Ls, RmSet, Dominators, Blocks);
find_loop_exit_1([L|Ls0], RmSet, Dominators, Blocks) ->
DomBy = map_get(L, Dominators),
- case any(fun(E) -> cerl_sets:is_element(E, RmSet) end, DomBy) of
+ case any(fun(E) -> sets:is_element(E, RmSet) end, DomBy) of
true ->
%% This block is dominated by one of the remove_message blocks,
%% which means that the block is part of only one clause.
@@ -1767,7 +1767,7 @@ find_rm_act([]) ->
%%%
-record(dk, {d :: ordsets:ordset(var_name()),
- k :: cerl_sets:set(var_name())
+ k :: sets:set(var_name())
}).
%% find_yregs(St0) -> St.
@@ -1790,10 +1790,10 @@ find_yregs(#st{frames=[_|_]=Frames,args=Args,ssa=Blocks0}=St) ->
St#st{ssa=Blocks}.
find_yregs_1([{F,Defs}|Fs], Blocks0) ->
- DK = #dk{d=Defs,k=cerl_sets:new()},
+ DK = #dk{d=Defs,k=sets:new([{version, 2}])},
D0 = #{F=>DK},
Ls = beam_ssa:rpo([F], Blocks0),
- Yregs0 = cerl_sets:new(),
+ Yregs0 = sets:new([{version, 2}]),
Yregs = find_yregs_2(Ls, Blocks0, D0, Yregs0),
Blk0 = map_get(F, Blocks0),
Blk = beam_ssa:add_anno(yregs, Yregs, Blk0),
@@ -1848,7 +1848,7 @@ find_update_succ([S|Ss], #dk{d=Defs0,k=Killed0}=DK0, D0) ->
case D0 of
#{S:=#dk{d=Defs1,k=Killed1}} ->
Defs = ordsets:intersection(Defs0, Defs1),
- Killed = cerl_sets:union(Killed0, Killed1),
+ Killed = sets:union(Killed0, Killed1),
DK = #dk{d=Defs,k=Killed},
D = D0#{S:=DK},
find_update_succ(Ss, DK0, D);
@@ -1860,13 +1860,13 @@ find_update_succ([], _, D) -> D.
find_yregs_is([#b_set{dst=Dst}=I|Is], #dk{d=Defs0,k=Killed0}=Ys, Yregs0) ->
Yregs1 = intersect_used(I, Killed0),
- Yregs = cerl_sets:union(Yregs0, Yregs1),
+ Yregs = sets:union(Yregs0, Yregs1),
case beam_ssa:clobbers_xregs(I) of
false ->
Defs = ordsets:add_element(Dst, Defs0),
find_yregs_is(Is, Ys#dk{d=Defs}, Yregs);
true ->
- Killed = cerl_sets:union(cerl_sets:from_list(Defs0), Killed0),
+ Killed = sets:union(sets:from_list(Defs0, [{version, 2}]), Killed0),
Defs = [Dst],
find_yregs_is(Is, Ys#dk{d=Defs,k=Killed}, Yregs)
end;
@@ -1874,28 +1874,28 @@ find_yregs_is([], Ys, Yregs) -> {Yregs,Ys}.
find_yregs_terminator(Terminator, #dk{k=Killed}, Yregs0) ->
Yregs = intersect_used(Terminator, Killed),
- cerl_sets:union(Yregs0, Yregs).
+ sets:union(Yregs0, Yregs).
intersect_used(#b_br{bool=#b_var{}=V}, Set) ->
intersect_used_keep_singleton(V, Set);
intersect_used(#b_ret{arg=#b_var{}=V}, Set) ->
intersect_used_keep_singleton(V, Set);
intersect_used(#b_set{op=phi,args=Args}, Set) ->
- cerl_sets:from_list([V || {#b_var{}=V,_} <- Args, cerl_sets:is_element(V, Set)]);
+ sets:from_list([V || {#b_var{}=V,_} <- Args, sets:is_element(V, Set)], [{version, 2}]);
intersect_used(#b_set{args=Args}, Set) ->
- cerl_sets:from_list(intersect_used_keep(used_args(Args), Set));
+ sets:from_list(intersect_used_keep(used_args(Args), Set), [{version, 2}]);
intersect_used(#b_switch{arg=#b_var{}=V}, Set) ->
intersect_used_keep_singleton(V, Set);
-intersect_used(_, _) -> cerl_sets:new().
+intersect_used(_, _) -> sets:new([{version, 2}]).
intersect_used_keep_singleton(V, Set) ->
- case cerl_sets:is_element(V, Set) of
- true -> cerl_sets:from_list([V]);
- false -> cerl_sets:new()
+ case sets:is_element(V, Set) of
+ true -> sets:from_list([V], [{version, 2}]);
+ false -> sets:new([{version, 2}])
end.
intersect_used_keep(Vs, Set) ->
- [V || V <- Vs, cerl_sets:is_element(V, Set)].
+ [V || V <- Vs, sets:is_element(V, Set)].
used_args([#b_var{}=V|As]) ->
[V|used_args(As)];
@@ -1996,8 +1996,8 @@ copy_retval_1([], Blocks, Count) ->
collect_yregs([#b_set{op=copy,dst=Y,args=[#b_var{}=X]}|Is],
Yregs0) ->
- true = cerl_sets:is_element(X, Yregs0), %Assertion.
- Yregs = cerl_sets:add_element(Y, cerl_sets:del_element(X, Yregs0)),
+ true = sets:is_element(X, Yregs0), %Assertion.
+ Yregs = sets:add_element(Y, sets:del_element(X, Yregs0)),
collect_yregs(Is, Yregs);
collect_yregs([#b_set{}|Is], Yregs) ->
collect_yregs(Is, Yregs);
@@ -2042,7 +2042,7 @@ copy_retval_is([#b_set{},#b_set{op=succeeded}]=Is, false, _Yregs, Copy, Count, A
copy_retval_is([#b_set{op=Op,dst=#b_var{name=RetName}=Dst}=I0|Is], RC, Yregs,
Copy0, Count0, Acc0) when Op =:= call; Op =:= make_fun ->
{I1,Count1,Acc} = place_retval_copy(I0, Yregs, Copy0, Count0, Acc0),
- case cerl_sets:is_element(Dst, Yregs) of
+ case sets:is_element(Dst, Yregs) of
true ->
{NewVar,Count} = new_var(RetName, Count1),
Copy = #b_set{op=copy,dst=Dst,args=[NewVar]},
@@ -2100,7 +2100,7 @@ place_retval_copy(#b_set{args=[F|Args0]}=I, Yregs, Copy, Count0, Acc0) ->
{I#b_set{args=[F|Args]},Count,Acc}.
copy_func_args([#b_var{name=AName}=A|As], Yregs, Avoid, CopyAcc, Acc, Count0) ->
- case cerl_sets:is_element(A, Yregs) of
+ case sets:is_element(A, Yregs) of
true when A =/= Avoid ->
{NewVar,Count} = new_var(AName, Count0),
Copy = #b_set{op=copy,dst=NewVar,args=[A]},
@@ -2402,7 +2402,7 @@ reserve_yregs(#st{frames=Frames}=St0) ->
reserve_yregs_1(L, #st{ssa=Blocks0,cnt=Count0,res=Res0}=St) ->
Blk = map_get(L, Blocks0),
- Yregs = ordsets:from_list(cerl_sets:to_list(beam_ssa:get_anno(yregs, Blk))),
+ Yregs = ordsets:from_list(sets:to_list(beam_ssa:get_anno(yregs, Blk))),
RPO = beam_ssa:rpo([L], Blocks0),
{Def,Unused} = beam_ssa:def_unused(RPO, Yregs, Blocks0),
UsedYregs = ordsets:subtract(Yregs, Unused),
@@ -2592,7 +2592,7 @@ reserve_arg_regs([], _, Acc) -> Acc.
reserve_zregs(RPO, Blocks, Intervals, Res) ->
ShortLived0 = [V || {V,[{Start,End}]} <- Intervals, Start+2 =:= End],
- ShortLived = cerl_sets:from_list(ShortLived0),
+ ShortLived = sets:from_list(ShortLived0, [{version, 2}]),
F = fun(_, #b_blk{is=Is,last=Last}, A) ->
reserve_zreg(Is, Last, ShortLived, A)
end,
@@ -2657,7 +2657,7 @@ use_zreg(_) -> maybe.
%% If V is defined just before a branch, we may be able to combine it into a
%% test instruction.
reserve_test_zreg(#b_var{}=V, ShortLived, A) ->
- case cerl_sets:is_element(V, ShortLived) of
+ case sets:is_element(V, ShortLived) of
true -> [{V,z}|A];
false -> A
end.
diff --git a/lib/compiler/src/beam_ssa_throw.erl b/lib/compiler/src/beam_ssa_throw.erl
index 3e0ce49056..fc0d53e6ab 100644
--- a/lib/compiler/src/beam_ssa_throw.erl
+++ b/lib/compiler/src/beam_ssa_throw.erl
@@ -56,7 +56,7 @@
%% Per-module scan state
-record(gst, {tlh_roots :: gb_trees:tree(#b_local{}, gb_sets:set(handler())),
tlh_edges=#{} :: #{ #b_local{} => gb_sets:set(#b_local{}) },
- throws=cerl_sets:new() :: cerl_sets:set(#b_local{})}).
+ throws=sets:new([{version, 2}]) :: sets:set(#b_local{})}).
%% Per-function scan state
-record(lst, {suitability=#{} :: #{ #b_var{} => suitability() },
@@ -106,7 +106,7 @@ scan_1([], Gst) ->
tlh_edges=Edges,
throws=Throws} = Gst,
- case cerl_sets:size(Throws) of
+ case sets:size(Throws) of
0 ->
no_throws;
_ ->
@@ -174,7 +174,7 @@ si_is([#b_set{op=call,
Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) ->
%% Tail throw, handled by caller. We'll need to visit this function again.
#gst{throws=Throws0} = Gst,
- Throws = cerl_sets:add_element(Id, Throws0),
+ Throws = sets:add_element(Id, Throws0),
{Lst, Gst#gst{throws=Throws}};
si_is([#b_set{op=call,dst=Dst,args=[#b_local{}=Callee | _]}],
Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) ->
@@ -297,7 +297,7 @@ add_tlh(Id, Callee, Lst, Gst) ->
opt([#b_function{bs=Blocks0}=F | Fs], Throws, TLHs) ->
Id = get_func_id(F),
- Blocks = case {cerl_sets:is_element(Id, Throws), TLHs} of
+ Blocks = case {sets:is_element(Id, Throws), TLHs} of
{true, #{ Id := Handlers } } ->
opt_function(Handlers, Blocks0);
{_, _} ->
diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl
index 434f90757c..21f3a70b9a 100644
--- a/lib/compiler/src/beam_ssa_type.erl
+++ b/lib/compiler/src/beam_ssa_type.erl
@@ -60,7 +60,7 @@
{ func_id :: func_id(),
limit_return :: boolean(),
params :: [beam_ssa:b_var()],
- used_once :: cerl_sets:set(beam_ssa:b_var()) }).
+ used_once :: sets:set(beam_ssa:b_var()) }).
-type type_db() :: #{ beam_ssa:var_name() := type() }.
@@ -1532,7 +1532,7 @@ update_successors(#b_br{bool=#b_literal{val=true},succ=Succ}=Last,
{Last, update_successor(Succ, Ts, Ls)};
update_successors(#b_br{bool=#b_var{}=Bool,succ=Succ,fail=Fail}=Last0,
Ts, Ds, Ls0, UsedOnce) ->
- IsTempVar = cerl_sets:is_element(Bool, UsedOnce),
+ IsTempVar = sets:is_element(Bool, UsedOnce),
case infer_types_br(Bool, Ts, IsTempVar, Ds) of
{#{}=SuccTs, #{}=FailTs} ->
Ls1 = update_successor(Succ, SuccTs, Ls0),
@@ -1547,7 +1547,7 @@ update_successors(#b_br{bool=#b_var{}=Bool,succ=Succ,fail=Fail}=Last0,
end;
update_successors(#b_switch{arg=#b_var{}=V,fail=Fail0,list=List0}=Last0,
Ts, Ds, Ls0, UsedOnce) ->
- IsTempVar = cerl_sets:is_element(V, UsedOnce),
+ IsTempVar = sets:is_element(V, UsedOnce),
{List1, FailTs, Ls1} =
update_switch(List0, V, raw_type(V, Ts), Ts, Ds, Ls0, IsTempVar, []),
@@ -2114,7 +2114,7 @@ gcd(A, B) ->
init_metadata(FuncId, Linear, Params) ->
{RetCounter, Map0} = init_metadata_1(reverse(Linear), 0, #{}),
Map = maps:without(Params, Map0),
- UsedOnce = cerl_sets:from_list(maps:keys(Map)),
+ UsedOnce = sets:from_list(maps:keys(Map), [{version, 2}]),
#metadata{ func_id = FuncId,
limit_return = (RetCounter >= ?RETURN_LIMIT),
diff --git a/lib/compiler/src/beam_trim.erl b/lib/compiler/src/beam_trim.erl
index 05e320c255..7dae102181 100644
--- a/lib/compiler/src/beam_trim.erl
+++ b/lib/compiler/src/beam_trim.erl
@@ -24,7 +24,7 @@
-import(lists, [any/2,member/2,reverse/1,reverse/2,splitwith/2,sort/1]).
-record(st,
- {safe :: cerl_sets:set(beam_asm:label()) %Safe labels.
+ {safe :: sets:set(beam_asm:label()) %Safe labels.
}).
-spec module(beam_utils:module_code(), [compile:option()]) ->
@@ -218,14 +218,14 @@ create_map(Trim, []) ->
create_map(Trim, Moves) ->
Map0 = [{Src,Dst-Trim} || {move,{y,Src},{y,Dst}} <- Moves],
Map = maps:from_list(Map0),
- IllegalTargets = cerl_sets:from_list([Dst || {move,_,{y,Dst}} <- Moves]),
+ IllegalTargets = sets:from_list([Dst || {move,_,{y,Dst}} <- Moves], [{version, 2}]),
fun({y,Y0}) when Y0 < Trim ->
case Map of
#{Y0:=Y} -> {y,Y};
#{} -> throw(not_possible)
end;
({y,Y}) ->
- case cerl_sets:is_element(Y, IllegalTargets) of
+ case sets:is_element(Y, IllegalTargets) of
true -> throw(not_possible);
false -> {y,Y-Trim}
end;
@@ -330,7 +330,7 @@ safe_labels([{label,L}|Is], Acc) ->
end;
safe_labels([_|Is], Acc) ->
safe_labels(Is, Acc);
-safe_labels([], Acc) -> cerl_sets:from_list(Acc).
+safe_labels([], Acc) -> sets:from_list(Acc, [{version, 2}]).
is_safe_label([{'%',_}|Is]) ->
is_safe_label(Is);
@@ -447,7 +447,7 @@ frame_size(_, _) -> throw(not_possible).
frame_size_branch(0, Is, Safe) ->
frame_size(Is, Safe);
frame_size_branch(L, Is, Safe) ->
- case cerl_sets:is_element(L, Safe) of
+ case sets:is_element(L, Safe) of
false -> throw(not_possible);
true -> frame_size(Is, Safe)
end.
diff --git a/lib/compiler/src/beam_validator.erl b/lib/compiler/src/beam_validator.erl
index db2cc30e89..4df5c92c13 100644
--- a/lib/compiler/src/beam_validator.erl
+++ b/lib/compiler/src/beam_validator.erl
@@ -181,7 +181,7 @@ validate_0([{function, Name, Arity, Entry, Code} | Fs], Module, Level, Ft) ->
%% A set of all registers containing "fragile" terms. That is, terms
%% that don't exist on our process heap and would be destroyed by a
%% GC.
- fragile=cerl_sets:new() :: cerl_sets:set(),
+ fragile=sets:new([{version, 2}]) :: sets:set(),
%% Number of Y registers.
%%
%% Note that this may be 0 if there's a frame without saved values,
@@ -228,7 +228,7 @@ validate_0([{function, Name, Arity, Entry, Code} | Fs], Module, Level, Ft) ->
%% States at labels
branched=#{} :: #{ label() => state() },
%% All defined labels
- labels=cerl_sets:new() :: cerl_sets:set(),
+ labels=sets:new([{version, 2}]) :: sets:set(),
%% Information of other functions in the module
ft=#{} :: #{ label() => map() },
%% Counter for #value_ref{} creation
@@ -296,7 +296,7 @@ init_vst({_, _, Arity}, Level, Ft) ->
Vst = #vst{branched=#{},
current=#st{},
ft=Ft,
- labels=cerl_sets:new(),
+ labels=sets:new([{version, 2}]),
level=Level},
init_function_args(Arity - 1, Vst).
@@ -311,7 +311,7 @@ kill_heap_allocation(St) ->
validate_branches(MFA, Vst) ->
#vst{ branched=Targets0, labels=Labels0 } = Vst,
Targets = maps:keys(Targets0),
- Labels = cerl_sets:to_list(Labels0),
+ Labels = sets:to_list(Labels0),
case Targets -- Labels of
[_|_]=Undef ->
Error = {undef_labels, Undef},
@@ -338,7 +338,7 @@ vi({label,Lbl}, #vst{current=St0,
{St, Counter} = merge_states(Lbl, St0, Branched0, Counter0),
Branched = Branched0#{ Lbl => St },
- Labels = cerl_sets:add_element(Lbl, Labels0),
+ Labels = sets:add_element(Lbl, Labels0),
Vst#vst{current=St,
ref_ctr=Counter,
@@ -1791,7 +1791,7 @@ heap_alloc_2([], St) -> St.
prune_x_regs(Live, #vst{current=St0}=Vst) when is_integer(Live) ->
#st{fragile=Fragile0,xs=Xs0} = St0,
- Fragile = cerl_sets:filter(fun({x,X}) ->
+ Fragile = sets:filter(fun({x,X}) ->
X < Live;
({y,_}) ->
true
@@ -1910,7 +1910,7 @@ assert_unique_map_keys([_,_|_]=Ls) ->
assert_literal(L),
L
end || L <- Ls],
- case length(Vs) =:= cerl_sets:size(cerl_sets:from_list(Vs)) of
+ case length(Vs) =:= sets:size(sets:from_list(Vs, [{version, 2}])) of
true -> ok;
false -> error(keys_not_unique)
end.
@@ -2749,7 +2749,7 @@ mv_args([], _VsA, _VsB, Acc) ->
Acc.
merge_fragility(FragileA, FragileB) ->
- cerl_sets:union(FragileA, FragileB).
+ sets:union(FragileA, FragileB).
merge_ms_positions(MsPosA, MsPosB, Vs) ->
Keys = if
@@ -2928,17 +2928,17 @@ set_receive_marker(New, #vst{current=#st{recv_marker=Current}=St0}=Vst) ->
%% Marks Reg as fragile.
mark_fragile(Reg, Vst) ->
#vst{current=#st{fragile=Fragile0}=St0} = Vst,
- Fragile = cerl_sets:add_element(Reg, Fragile0),
+ Fragile = sets:add_element(Reg, Fragile0),
St = St0#st{fragile=Fragile},
Vst#vst{current=St}.
propagate_fragility(Reg, Args, #vst{current=St0}=Vst) ->
#st{fragile=Fragile0} = St0,
- Sources = cerl_sets:from_list(Args),
- Fragile = case cerl_sets:is_disjoint(Sources, Fragile0) of
- true -> cerl_sets:del_element(Reg, Fragile0);
- false -> cerl_sets:add_element(Reg, Fragile0)
+ Sources = sets:from_list(Args, [{version, 2}]),
+ Fragile = case sets:is_disjoint(Sources, Fragile0) of
+ true -> sets:del_element(Reg, Fragile0);
+ false -> sets:add_element(Reg, Fragile0)
end,
St = St0#st{fragile=Fragile},
@@ -2948,9 +2948,9 @@ propagate_fragility(Reg, Args, #vst{current=St0}=Vst) ->
%% a register.
remove_fragility(Reg, Vst) ->
#vst{current=#st{fragile=Fragile0}=St0} = Vst,
- case cerl_sets:is_element(Reg, Fragile0) of
+ case sets:is_element(Reg, Fragile0) of
true ->
- Fragile = cerl_sets:del_element(Reg, Fragile0),
+ Fragile = sets:del_element(Reg, Fragile0),
St = St0#st{fragile=Fragile},
Vst#vst{current=St};
false ->
@@ -2959,7 +2959,7 @@ remove_fragility(Reg, Vst) ->
%% Marks all registers as durable.
remove_fragility(#vst{current=St0}=Vst) ->
- St = St0#st{fragile=cerl_sets:new()},
+ St = St0#st{fragile=sets:new([{version, 2}])},
Vst#vst{current=St}.
assert_durable_term(Src, Vst) ->
@@ -2969,7 +2969,7 @@ assert_durable_term(Src, Vst) ->
assert_not_fragile({Kind,_}=Src, Vst) when Kind =:= x; Kind =:= y ->
check_limit(Src),
#vst{current=#st{fragile=Fragile}} = Vst,
- case cerl_sets:is_element(Src, Fragile) of
+ case sets:is_element(Src, Fragile) of
true -> error({fragile_message_reference, Src});
false -> ok
end;
diff --git a/lib/compiler/src/sys_core_alias.erl b/lib/compiler/src/sys_core_alias.erl
index 9343999980..96259d1530 100644
--- a/lib/compiler/src/sys_core_alias.erl
+++ b/lib/compiler/src/sys_core_alias.erl
@@ -46,7 +46,7 @@
-define(HAS_SUBS(Sub), Sub#sub.t =/= none).
-record(sub, {p=#{} :: #{term() => ?NOTSET | atom()}, %% Found pattern substitutions
- v=cerl_sets:new() :: cerl_sets:set(cerl:var_name()), %% Variables used by patterns
+ v=sets:new([{version, 2}]) :: sets:set(cerl:var_name()), %% Variables used by patterns
t=none :: temp()}). %% Temporary information from pre to post
-type sub() :: #sub{}.
@@ -64,7 +64,7 @@
none
| {temp, temp()}
| {sub, sub()}
- | {clause, [term()], [term()], cerl_sets:set(cerl:var_name()), temp()}.
+ | {clause, [term()], [term()], sets:set(cerl:var_name()), temp()}.
-spec module(cerl:c_module(), [compile:option()]) ->
{'ok',cerl:c_module(),[]}.
@@ -237,13 +237,13 @@ new_var_name(Key, #sub{p=Pat}=Sub) ->
%% merge_variables/2
get_variables(NodesList) ->
- cerl_sets:from_list([Var || Node <- NodesList, Var <- cerl_trees:variables(Node)]).
+ sets:from_list([Var || Node <- NodesList, Var <- cerl_trees:variables(Node)], [{version, 2}]).
is_disjoint_variables(Vars1, Vars2) ->
- cerl_sets:is_disjoint(Vars1, Vars2).
+ sets:is_disjoint(Vars1, Vars2).
merge_variables(Vars1, Vars2) ->
- cerl_sets:union(Vars1, Vars2).
+ sets:union(Vars1, Vars2).
%% get_pattern_keys/2
%% put_pattern_keys/2
diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index d987c6f3b5..704bddc2ac 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -95,7 +95,7 @@
%% Variable value info.
-record(sub, {v=[], %Variable substitutions
- s=cerl_sets:new() :: cerl_sets:set(), %Variables in scope
+ s=sets:new([{version, 2}]) :: sets:set(), %Variables in scope
t=#{} :: map(), %Types
in_guard=false}). %In guard or not.
@@ -1319,7 +1319,7 @@ is_subst(_) -> false.
%% to force renaming if variables in the scope occurs as pattern
%% variables.
-sub_new() -> #sub{v=orddict:new(),s=cerl_sets:new(),t=#{}}.
+sub_new() -> #sub{v=orddict:new(),s=sets:new([{version, 2}]),t=#{}}.
sub_new(#sub{}=Sub) ->
Sub#sub{v=orddict:new(),t=#{}}.
@@ -1336,7 +1336,7 @@ sub_set_var(#c_var{name=V}, Val, Sub) ->
sub_set_name(V, Val, #sub{v=S,s=Scope,t=Tdb0}=Sub) ->
Tdb1 = kill_types(V, Tdb0),
Tdb = copy_type(V, Val, Tdb1),
- Sub#sub{v=orddict:store(V, Val, S),s=cerl_sets:add_element(V, Scope),t=Tdb}.
+ Sub#sub{v=orddict:store(V, Val, S),s=sets:add_element(V, Scope),t=Tdb}.
sub_subst_var(#c_var{name=V}, Val, #sub{v=S0}) ->
%% Fold chained substitutions.
@@ -1344,7 +1344,7 @@ sub_subst_var(#c_var{name=V}, Val, #sub{v=S0}) ->
sub_add_scope(Vs, #sub{s=Scope0}=Sub) ->
Scope = foldl(fun(V, S) when is_integer(V); is_atom(V) ->
- cerl_sets:add_element(V, S)
+ sets:add_element(V, S)
end, Scope0, Vs),
Sub#sub{s=Scope}.
@@ -1355,7 +1355,7 @@ sub_subst_scope(#sub{v=S0,s=Scope}=Sub) ->
_ ->
-1
end,
- S = sub_subst_scope_1(cerl_sets:to_list(Scope), Initial, S0),
+ S = sub_subst_scope_1(sets:to_list(Scope), Initial, S0),
Sub#sub{v=orddict:from_list(S)}.
%% The keys in an orddict must be unique. Make them so!
@@ -1364,7 +1364,7 @@ sub_subst_scope_1([H|T], Key, Acc) ->
sub_subst_scope_1([], _, Acc) -> Acc.
sub_is_in_scope(#c_var{name=V}, #sub{s=Scope}) ->
- cerl_sets:is_element(V, Scope).
+ sets:is_element(V, Scope).
%% warn_no_clause_match(CaseOrig, CaseOpt) -> ok
%% Generate a warning if none of the user-specified clauses
@@ -2116,7 +2116,7 @@ is_bool_expr_list([]) -> true.
%% (i.e. it cannot fail).
%%
is_safe_bool_expr(Core) ->
- is_safe_bool_expr_1(Core, cerl_sets:new()).
+ is_safe_bool_expr_1(Core, sets:new([{version, 2}])).
is_safe_bool_expr_1(#c_call{module=#c_literal{val=erlang},
name=#c_literal{val=is_function},
@@ -2146,7 +2146,7 @@ is_safe_bool_expr_1(#c_let{vars=Vars,arg=Arg,body=B}, BoolVars) ->
true ->
case {is_safe_bool_expr_1(Arg, BoolVars),Vars} of
{true,[#c_var{name=V}]} ->
- is_safe_bool_expr_1(B, cerl_sets:add_element(V, BoolVars));
+ is_safe_bool_expr_1(B, sets:add_element(V, BoolVars));
{false,_} ->
is_safe_bool_expr_1(B, BoolVars)
end;
@@ -2155,7 +2155,7 @@ is_safe_bool_expr_1(#c_let{vars=Vars,arg=Arg,body=B}, BoolVars) ->
is_safe_bool_expr_1(#c_literal{val=Val}, _BoolVars) ->
is_boolean(Val);
is_safe_bool_expr_1(#c_var{name=V}, BoolVars) ->
- cerl_sets:is_element(V, BoolVars);
+ sets:is_element(V, BoolVars);
is_safe_bool_expr_1(_, _) -> false.
is_safe_bool_expr_list([C|Cs], BoolVars) ->
@@ -2228,7 +2228,7 @@ move_let_into_expr(#c_let{vars=Lvs0,body=Lbody0}=Let,
B1 = body(B0, ScopeSub),
{Lvs,B2,Sub1} = let_substs(Lvs0, B1, Sub0),
- Sub2 = Sub1#sub{s=cerl_sets:union(ScopeSub#sub.s,
+ Sub2 = Sub1#sub{s=sets:union(ScopeSub#sub.s,
Sub1#sub.s)},
Lbody = body(Lbody0, Sub2),
B = Let#c_let{vars=Lvs,
@@ -2488,7 +2488,7 @@ opt_simple_let_1(#c_let{vars=Vs0,body=B0}=Let, Arg0, Ctxt, Sub0) ->
%% Optimise let and add new substitutions.
{Vs,Args,Sub1} = let_substs(Vs0, Arg0, Sub0),
BodySub = update_let_types(Vs, Args, Sub1),
- Sub = Sub1#sub{v=[],s=cerl_sets:new()},
+ Sub = Sub1#sub{v=[],s=sets:new([{version, 2}])},
B = body(B0, Ctxt, BodySub),
Arg = core_lib:make_values(Args),
opt_simple_let_2(Let, Vs, Arg, B, B0, Sub).
@@ -2865,12 +2865,12 @@ verify_scope(E, #sub{s=Scope}) ->
false ->
io:format("~p\n", [E]),
io:format("~p\n", [Free]),
- io:format("~p\n", [ordsets:from_list(cerl_sets:to_list(Scope))]),
+ io:format("~p\n", [ordsets:from_list(sets:to_list(Scope))]),
false
end.
is_subset_of_scope([V|Vs], Scope) ->
- cerl_sets:is_element(V, Scope) andalso is_subset_of_scope(Vs, Scope);
+ sets:is_element(V, Scope) andalso is_subset_of_scope(Vs, Scope);
is_subset_of_scope([], _) -> true.
-endif.
diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index fa54a14067..e8576913b3 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -938,7 +938,7 @@ badmap_term(Map, #core{in_guard=false}) ->
c_tuple([#c_literal{val=badmap},Map]).
map_build_pairs(Map, Es0, Ann, St0) ->
- {Es,Pre,_,St1} = map_build_pairs_1(Es0, cerl_sets:new(), St0),
+ {Es,Pre,_,St1} = map_build_pairs_1(Es0, sets:new([{version, 2}]), St0),
{ann_c_map(Ann, Map, Es),Pre,St1}.
map_build_pairs_1([{Op0,L,K0,V0}|Es], Used0, St0) ->
@@ -958,11 +958,11 @@ maybe_warn_repeated_keys(Ck,Line,Used,St) ->
false -> {Used,St};
true ->
K = cerl:concrete(Ck),
- case cerl_sets:is_element(K,Used) of
+ case sets:is_element(K,Used) of
true ->
{Used, add_warning(Line, {map_key_repeated,K}, St)};
false ->
- {cerl_sets:add_element(K,Used), St}
+ {sets:add_element(K,Used), St}
end
end.
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index be7f9824fb..eb04a2c916 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -115,12 +115,12 @@ copy_anno(Kdst, Ksrc) ->
fargs=[] :: [#k_var{}], %Arguments for current function
vcount=0, %Variable counter
fcount=0, %Fun counter
- ds=cerl_sets:new() :: cerl_sets:set(), %Defined variables
+ ds=sets:new([{version, 2}]) :: sets:set(), %Defined variables
funs=[], %Fun functions
free=#{}, %Free variables
ws=[] :: [warning()], %Warnings.
no_shared_fun_wrappers=false :: boolean(),
- labels=cerl_sets:new()
+ labels=sets:new([{version, 2}])
}).
-spec module(cerl:c_module(), [compile:option()]) ->
@@ -165,7 +165,7 @@ function({#c_var{name={F,Arity}=FA},Body}, St0) ->
%% the function. We use integers as variable names to avoid
%% filling up the atom table when compiling huge functions.
Count = cerl_trees:next_free_variable_name(Body),
- St1 = St0#kern{func=FA,vcount=Count,fcount=0,ds=cerl_sets:new()},
+ St1 = St0#kern{func=FA,vcount=Count,fcount=0,ds=sets:new([{version, 2}])},
{#ifun{anno=Ab,vars=Kvs,body=B0},[],St2} = expr(Body, new_sub(), St1),
{B1,_,St3} = ubody(B0, return, St2),
%%B1 = B0, St3 = St2, %Null second pass
@@ -394,7 +394,7 @@ letrec_local_function(A, Cfs, Cb, Sub0, St0) ->
letrec_goto([{#c_var{name={Label,0}},Cfail}], Cb, Sub0,
#kern{labels=Labels0}=St0) ->
- Labels = cerl_sets:add_element(Label, Labels0),
+ Labels = sets:add_element(Label, Labels0),
{Kb,Pb,St1} = body(Cb, Sub0, St0#kern{labels=Labels}),
#c_fun{body=FailBody} = Cfail,
{Kfail,Fb,St2} = body(FailBody, Sub0, St1),
@@ -559,7 +559,7 @@ match_vars(Ka, St0) ->
%% Transform application.
c_apply(A, #c_var{anno=Ra,name={F0,Ar}}, Cargs, Sub, #kern{labels=Labels}=St0) ->
- case Ar =:= 0 andalso cerl_sets:is_element(F0, Labels) of
+ case Ar =:= 0 andalso sets:is_element(F0, Labels) of
true ->
%% This is a goto to a label in a letrec_goto construct.
{#k_goto{label=F0},[],St0};
@@ -666,15 +666,15 @@ force_variable(Ke, St0) ->
%% handling.
pattern(#c_var{anno=A,name=V}, _Isub, Osub, St0) ->
- case cerl_sets:is_element(V, St0#kern.ds) of
+ case sets:is_element(V, St0#kern.ds) of
true ->
{New,St1} = new_var_name(St0),
{#k_var{anno=A,name=New},
set_vsub(V, New, Osub),
- St1#kern{ds=cerl_sets:add_element(New, St1#kern.ds)}};
+ St1#kern{ds=sets:add_element(New, St1#kern.ds)}};
false ->
{#k_var{anno=A,name=V},Osub,
- St0#kern{ds=cerl_sets:add_element(V, St0#kern.ds)}}
+ St0#kern{ds=sets:add_element(V, St0#kern.ds)}}
end;
pattern(#c_literal{anno=A,val=Val}, _Isub, Osub, St) ->
{#k_literal{anno=A,val=Val},Osub,St};
@@ -1446,7 +1446,7 @@ partition_intersection(_, Us, Cs, St) ->
partition_keys(#k_map{es=Pairs}=Map, Ks) ->
F = fun(#k_map_pair{key=Key}) ->
- cerl_sets:is_element(map_key_clean(Key), Ks)
+ sets:is_element(map_key_clean(Key), Ks)
end,
{Ps1,Ps2} = partition(F, Pairs),
{Map#k_map{es=Ps1},Map#k_map{es=Ps2}};
@@ -1456,9 +1456,9 @@ partition_keys(#ialias{pat=Map}=Alias, Ks) ->
{Map1,Alias#ialias{pat=Map2}}.
find_key_intersection(Ps) ->
- Sets = [cerl_sets:from_list(Ks) || Ks <- Ps],
- Intersection = cerl_sets:intersection(Sets),
- case cerl_sets:size(Intersection) of
+ Sets = [sets:from_list(Ks, [{version, 2}]) || Ks <- Ps],
+ Intersection = sets:intersection(Sets),
+ case sets:size(Intersection) of
0 ->
none;
_ ->
--
2.26.2
