File 2851-compiler-Remove-cerl_sets-usage.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2851-compiler-Remove-cerl_sets-usage.patch of Package erlang (Revision 34b3562de4bf474ac17fe559432197c9)

Currently displaying revision 34b3562de4bf474ac17fe559432197c9 , Show latest

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

Places

File 2851-compiler-Remove-cerl_sets-usage.patch of Package erlang (Revision 34b3562de4bf474ac17fe559432197c9)

Places