File 5609-v3_core-Handle-map-comprehensions.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 5609-v3_core-Handle-map-comprehensions.patch of Package erlang (Revision c681b8899ee889480c6f6ce3b6554db6)

Currently displaying revision c681b8899ee889480c6f6ce3b6554db6 , Show latest

From 0de6bc8226e78326373aabb93ea9654ed44bb837 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 17 Jan 2023 08:58:23 +0100
Subject: [PATCH 09/12] v3_core: Handle map comprehensions

---
 lib/compiler/src/v3_core.erl           | 191 ++++++++++++-----
 lib/compiler/test/Makefile             |   3 +
 lib/compiler/test/bs_bincomp_SUITE.erl |   2 +
 lib/compiler/test/lc_SUITE.erl         |   8 +
 lib/compiler/test/mc_SUITE.erl         | 272 +++++++++++++++++++++++++
 lib/compiler/test/record_SUITE.erl     |   8 +
 6 files changed, 430 insertions(+), 54 deletions(-)
 create mode 100644 lib/compiler/test/mc_SUITE.erl

diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index eb337672ff..cedb162eef 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -120,7 +120,8 @@
 -record(itry,      {anno=#a{},args,vars,body,evars,handler}).
 -record(ifilter,   {anno=#a{},arg}).
 -record(igen,      {anno=#a{},acc_pat,acc_guard,
-		    skip_pat,tail,tail_pat,arg}).
+                    skip_pat,tail,tail_pat,arg,
+                    refill={nomatch,ignore}}).
 -record(isimple,   {anno=#a{},term :: cerl:cerl()}).
 
 -type iapply()    :: #iapply{}.
@@ -691,6 +692,9 @@ expr({lc,L,E,Qs0}, St0) ->
     lc_tq(L, E, Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
 expr({bc,L,E,Qs}, St) ->
     bc_tq(L, E, Qs, St);
+expr({mc,L,E,Qs0}, St0) ->
+    {Qs1,St1} = preprocess_quals(L, Qs0, St0),
+    mc_tq(L, E, Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
 expr({tuple,L,Es0}, St0) ->
     {Es1,Eps,St1} = safe_list(Es0, St0),
     A = record_anno(L, St1),
@@ -1594,37 +1598,31 @@ fun_tq(Cs0, L, St0, NameInfo) ->
     {Fun,[],St4}.
 
 %% lc_tq(Line, Exp, [Qualifier], Mc, State) -> {LetRec,[PreExp],State}.
-%%  This TQ from Simon PJ pp 127-138.  
+%%  This TQ from Simon PJ pp 127-138.
 
 lc_tq(Line, E, [#igen{anno=#a{anno=GA}=GAnno,
 		      acc_pat=AccPat,acc_guard=AccGuard,
                       skip_pat=SkipPat,tail=Tail,tail_pat=TailPat,
+                      refill={RefillPat,RefillAction},
                       arg={Pre,Arg}}|Qs], Mc, St0) ->
     {Name,St1} = new_fun_name("lc", St0),
     LA = lineno_anno(Line, St1),
-    LAnno = #a{anno=LA},
     F = #c_var{anno=LA,name={Name,1}},
     Nc = #iapply{anno=GAnno,op=F,args=[Tail]},
     {[FcVar,Var],St2} = new_vars(2, St1),
     Fc = bad_generator([FcVar], FcVar, Arg),
-    SkipClause = #iclause{anno=#a{anno=[skip_clause,compiler_generated|LA]},
-                          pats=[SkipPat],guard=[],body=[Nc]},
-    TailClause = #iclause{anno=LAnno,pats=[TailPat],guard=[],body=[Mc]},
-    {Cs,St4} = case {AccPat,SkipPat} of
-                   {nomatch,nomatch} ->
-                       {[TailClause],St2};
-                   {nomatch,_} ->
-                       {[SkipClause,TailClause],St2};
-                   _ ->
-                       {Lc,Lps,St3} = lc_tq(Line, E, Qs, Nc, St2),
-                       AccClause = #iclause{anno=LAnno,pats=[AccPat],guard=AccGuard,
-                                            body=Lps ++ [Lc]},
-                       {[AccClause,SkipClause,TailClause],St3}
-               end,
+    SkipClause = make_clause([skip_clause,compiler_generated|LA],
+                             SkipPat, [], [], [Nc]),
+    TailClause = make_clause(LA, TailPat, [], [], [Mc]),
+    {Lc,Lps,St3} = lc_tq(Line, E, Qs, Nc, St2),
+    AccClause = make_clause(LA, AccPat, [], AccGuard, Lps ++ [Lc]),
+    RefillClause = make_clause(LA, RefillPat, [], [], [RefillAction,Nc]),
+    Cs0 = [AccClause,SkipClause,TailClause,RefillClause],
+    Cs = [C || C <- Cs0, C =/= nomatch],
     Fun = #ifun{anno=GAnno,id=[],vars=[Var],clauses=Cs,fc=Fc},
     {#iletrec{anno=GAnno#a{anno=[list_comprehension|GA]},defs=[{{Name,1},Fun}],
               body=Pre ++ [#iapply{anno=GAnno,op=F,args=[Arg]}]},
-     [],St4};
+     [],St3};
 lc_tq(Line, E, [#ifilter{}=Filter|Qs], Mc, St) ->
     filter_tq(Line, E, Filter, Mc, St, Qs, fun lc_tq/5);
 lc_tq(Line, E0, [], Mc0, St0) ->
@@ -1659,6 +1657,7 @@ bc_tq(Line, Exp, Qs0, St0) ->
 bc_tq1(Line, E, [#igen{anno=GAnno,
 		       acc_pat=AccPat,acc_guard=AccGuard,
                        skip_pat=SkipPat,tail=Tail,tail_pat=TailPat,
+                       refill={RefillPat,RefillAction},
                        arg={Pre,Arg}}|Qs], Mc, St0) ->
     {Name,St1} = new_fun_name("lbc", St0),
     LA = lineno_anno(Line, St1),
@@ -1669,30 +1668,23 @@ bc_tq1(Line, E, [#igen{anno=GAnno,
     F = #c_var{anno=LA,name={Name,2}},
     Nc = #iapply{anno=GAnno,op=F,args=[Tail,AccVar]},
     Fc = bad_generator(FcVars, hd(FcVars), Arg),
-    SkipClause = #iclause{anno=#a{anno=[compiler_generated,skip_clause|LA]},
-                          pats=[SkipPat,IgnoreVar],guard=[],body=[Nc]},
-    TailClause = #iclause{anno=LAnno,pats=[TailPat,IgnoreVar],guard=[],
-                          body=[AccVar]},
-    {Cs,St} = case {AccPat,SkipPat} of
-                  {nomatch,nomatch} ->
-                      {[TailClause],St4};
-                  {nomatch,_} ->
-                      {[SkipClause,TailClause],St4};
-                  {_,_} ->
-                      {Bc,Bps,St5} = bc_tq1(Line, E, Qs, AccVar, St4),
-                      Body = Bps ++ [#iset{var=AccVar,arg=Bc},Nc],
-                      AccClause = #iclause{anno=LAnno,pats=[AccPat,IgnoreVar],
-                                           guard=AccGuard,body=Body},
-                      {[AccClause,SkipClause,TailClause],St5}
-              end,
-    Fun = #ifun{anno=LAnno,id=[],vars=Vars,clauses=Cs,fc=Fc},
+    SkipClause = make_clause([compiler_generated,skip_clause|LA],
+                             SkipPat, [IgnoreVar], [], [Nc]),
+    TailClause = make_clause(LA, TailPat, [IgnoreVar], [], [AccVar]),
+    {Bc,Bps,St5} = bc_tq1(Line, E, Qs, AccVar, St4),
+    Body = Bps ++ [#iset{var=AccVar,arg=Bc},Nc],
+    AccClause = make_clause(LA, AccPat, [IgnoreVar], AccGuard, Body),
+    RefillClause = make_clause(LA, RefillPat, [AccVar], [], [RefillAction,Nc]),
+    Cs0 = [AccClause,SkipClause,TailClause,RefillClause],
+    Cs = [C || C <- Cs0, C =/= nomatch],
+    Fun = #ifun{anno=GAnno,id=[],vars=Vars,clauses=Cs,fc=Fc},
 
     %% Inlining would disable the size calculation optimization for
     %% bs_init_writable.
     {#iletrec{anno=LAnno#a{anno=[list_comprehension,no_inline|LA]},
               defs=[{{Name,2},Fun}],
               body=Pre ++ [#iapply{anno=LAnno,op=F,args=[Arg,Mc]}]},
-     [],St};
+     [],St5};
 bc_tq1(Line, E, [#ifilter{}=Filter|Qs], Mc, St) ->
     filter_tq(Line, E, Filter, Mc, St, Qs, fun bc_tq1/5);
 bc_tq1(_, {bin,Bl,Elements}, [], AccVar, St0) ->
@@ -1729,6 +1721,20 @@ bc_tq_build(Line, Pre0, #c_var{name=AccVar}, Elements0, St0) ->
     Anno = Anno0#a{anno=[compiler_generated,single_use|A]},
     {set_anno(E, Anno),Pre0++Pre,St}.
 
+mc_tq(Line, {map_field_assoc,Lf,K,V}, Qs, Mc, St0) ->
+    E = {tuple,Lf,[K,V]},
+    {Lc,Pre0,St1} = lc_tq(Line, E, Qs, Mc, St0),
+    {LcVar,St2} = new_var(St1),
+    Pre = Pre0 ++ [#iset{var=LcVar,arg=Lc}],
+    Call = #icall{module=#c_literal{val=maps},
+                  name=#c_literal{val=from_list},
+                  args=[LcVar]},
+    {Call,Pre,St2}.
+
+make_clause(_Anno, nomatch, _PatExtra, _Guard, _Body) ->
+    nomatch;
+make_clause(Anno, Pat, PatExtra, Guard, Body) ->
+    #iclause{anno=#a{anno=Anno},pats=[Pat|PatExtra],guard=Guard,body=Body}.
 
 %% filter_tq(Line, Expr, Filter, Mc, State, [Qualifier], TqFun) ->
 %%     {Case,[PreExpr],State}.
@@ -1805,6 +1811,7 @@ preprocess_quals(_, [], St, Acc) ->
 
 is_generator({generate,_,_,_}) -> true;
 is_generator({b_generate,_,_,_}) -> true;
+is_generator({m_generate,_,_,_}) -> true;
 is_generator(_) -> false.
 
 %% Retrieve the annotation from an Erlang AST form.
@@ -1813,7 +1820,7 @@ is_generator(_) -> false.
 get_qual_anno(Abstract) -> element(2, Abstract).
 
 %%
-%% Generators are abstracted as sextuplets:
+%% Generators are abstracted as a record #igen{}:
 %%  - acc_pat is the accumulator pattern, e.g. [Pat|Tail] for Pat <- Expr.
 %%  - acc_guard is the list of guards immediately following the current
 %%    generator in the qualifier list input.
@@ -1823,6 +1830,8 @@ get_qual_anno(Abstract) -> element(2, Abstract).
 %%    generator input.
 %%  - tail_pat is the tail pattern, respectively [] and <<_/bitstring>> for list
 %%    and bit string generators.
+%%  - refill is a pair {RefillPat,RefillAction}, used to refill the iterator
+%%    argument (used by map generators).
 %%  - arg is a pair {Pre,Arg} where Pre is the list of expressions to be
 %%    inserted before the comprehension function and Arg is the expression
 %%    that it should be passed.
@@ -1837,22 +1846,13 @@ generator(Line, {generate,Lg,P0,E}, Gs, St0) ->
     {Head,St1} = list_gen_pattern(P0, Line, St0),
     {[Tail,Skip],St2} = new_vars(2, St1),
     {Cg,St3} = lc_guard_tests(Gs, St2),
-    {AccPat,SkipPat} = case Head of
-                           #c_var{} ->
-                               %% If the generator pattern is a variable, the
-                               %% pattern from the accumulator clause can be
-                               %% reused in the skip one. lc_tq and bc_tq1 takes
-                               %% care of dismissing the latter in that case.
-                               Cons = ann_c_cons(LA, Head, Tail),
-                               {Cons,Cons};
-                           nomatch ->
-                               %% If it never matches, there is no need for
-                               %% an accumulator clause.
-                               {nomatch,ann_c_cons(LA, Skip, Tail)};
-                           _ ->
-                               {ann_c_cons(LA, Head, Tail),
-                                ann_c_cons(LA, Skip, Tail)}
-                       end,
+    AccPat = case Head of
+                 nomatch ->
+                     nomatch;
+                 _ ->
+                     ann_c_cons(LA, Head, Tail)
+             end,
+    SkipPat = ann_c_cons(LA, Skip, Tail),
     {Ce,Pre,St4} = safe(E, St3),
     Gen = #igen{anno=#a{anno=GA},
 		acc_pat=AccPat,acc_guard=Cg,skip_pat=SkipPat,
@@ -1885,7 +1885,90 @@ generator(Line, {b_generate,Lg,P,E}, Gs, St0) ->
                         tail_pat=#c_var{name='_'},
                         arg={Pre,Ce}},
             {Gen,St1}
-    end.
+    end;
+generator(Line, {m_generate,Lg,{map_field_exact,_,K0,V0},E}, Gs, St0) ->
+    %% Consider this example:
+    %%
+    %%   [{K,V} || K := V <- L].
+    %%
+    %% The following Core Erlang code will be generated:
+    %%
+    %% letrec
+    %%     'lc$^0'/1 =
+    %%         fun (Iter0) ->
+    %%             case Iter0 of
+    %%               <{K,V,NextIter}> when 'true' ->
+    %%                   let <Tail> =
+    %%                       apply 'lc$^0'/1(NextIter)
+    %%                   in [{K,V}|Tail]
+    %%               <{_K,_V,NextIter}> when 'true' ->
+    %%                   %% Skip clause; will be optimized away later
+    %%                   %% since there are no filters.
+    %%                   apply 'lc$^0'/1(NextIter)
+    %%               <'none'> when 'true' ->
+    %%                   []
+    %%               <Iter> when 'true' ->
+    %%                   let NextIter =
+    %%                       call 'erts_internal':'mc_refill'(Iter)
+    %%                   in apply 'lc$^0'/1(NextIter)
+    %%               <Bad> when 'true' ->
+    %%                     %% Generated by lc_tq/5. Never reached;
+    %%                     %% will be optimized away.
+    %%                     call 'erlang':'error'({'bad_generator',Bad})
+    %%             end
+    %% in let <Iter> =
+    %%         case call 'erts_internal':'mc_iterator'(L) of
+    %%           <[]> when 'true' ->
+    %%                 call 'erlang':'error'
+    %%                     ({'bad_generator',L})
+    %%           <Iter0> when 'true' ->
+    %%               Iter0
+    %%         end
+    %%     in apply 'lc$^0'/1(Iter0)
+    LA = lineno_anno(Line, St0),
+    GA = lineno_anno(Lg, St0),
+    {Pat,St1} = list_gen_pattern({cons,Lg,K0,V0}, Line, St0),
+    {[SkipK,SkipV,IterVar,OuterIterVar,_BadGenVar],St2} = new_vars(5, St1),
+    {Cg,St3} = lc_guard_tests(Gs, St2),
+    {Ce,Pre0,St4} = safe(E, St3),
+    AccPat = case Pat of
+                 #c_cons{hd=K,tl=V} ->
+                     #c_tuple{es=[K,V,IterVar]};
+                 nomatch ->
+                     nomatch
+             end,
+    SkipPat = #c_tuple{es=[SkipK,SkipV,IterVar]},
+
+    Refill = {SkipK,
+              #iset{var=IterVar,
+                    arg=#icall{anno=#a{anno=GA},
+                               module=#c_literal{val=erts_internal},
+                               name=#c_literal{val=mc_refill},
+                               args=[SkipK]}}},
+
+    InitIter = #icall{anno=#a{anno=GA},
+                      module=#c_literal{val=erts_internal},
+                      name=#c_literal{val=mc_iterator},
+                      args=[Ce]},
+
+    BadGenerator = bad_generator([#c_literal{val=[]}], Ce,
+                                 #c_literal{val=[],anno=GA}),
+    BeforeFc = #iclause{anno=#a{anno=GA},
+                        pats=[IterVar],
+                        guard=[],
+                        body=[IterVar]},
+    Before = #iset{var=OuterIterVar,
+                   arg=#icase{args=[InitIter],
+                              clauses=[BadGenerator],
+                              fc=BeforeFc}},
+
+    Pre = Pre0 ++ [Before],
+    Gen = #igen{anno=#a{anno=GA},
+		acc_pat=AccPat,acc_guard=Cg,skip_pat=SkipPat,
+                tail=IterVar,tail_pat=#c_literal{anno=LA,val=none},
+                refill=Refill,
+                arg={Pre,OuterIterVar}},
+    {Gen,St4}.
 
 append_tail_segment(Segs, St0) ->
     {Var,St} = new_var(St0),
diff --git a/lib/compiler/test/Makefile b/lib/compiler/test/Makefile
index 3a585fc10e..19720abe50 100644
--- a/lib/compiler/test/Makefile
+++ b/lib/compiler/test/Makefile
@@ -41,6 +41,7 @@ MODULES= \
 	map_SUITE \
 	match_SUITE \
 	maybe_SUITE \
+	mc_SUITE \
 	misc_SUITE \
 	overridden_bif_SUITE \
 	random_code_SUITE \
@@ -76,6 +77,7 @@ NO_OPT= \
 	map \
 	match \
 	maybe \
+        mc \
 	misc \
 	overridden_bif \
 	receive \
@@ -103,6 +105,7 @@ INLINE= \
 	map \
 	match \
 	maybe \
+	mc \
 	misc \
 	overridden_bif \
 	receive \
diff --git a/lib/compiler/test/bs_bincomp_SUITE.erl b/lib/compiler/test/bs_bincomp_SUITE.erl
index d6718c6e9c..b560203514 100644
--- a/lib/compiler/test/bs_bincomp_SUITE.erl
+++ b/lib/compiler/test/bs_bincomp_SUITE.erl
@@ -626,6 +626,8 @@ cs(Bin) ->
             ok;
         bs_bincomp_no_ssa_opt_SUITE ->
             ok;
+        bs_bincomp_no_copt_SUITE ->
+            ok;
         bs_bincomp_post_opt_SUITE ->
             ok;
         _ ->
diff --git a/lib/compiler/test/lc_SUITE.erl b/lib/compiler/test/lc_SUITE.erl
index 7d30f1c74f..ab683f4de1 100644
--- a/lib/compiler/test/lc_SUITE.erl
+++ b/lib/compiler/test/lc_SUITE.erl
@@ -124,6 +124,11 @@ basic(Config) when is_list(Config) ->
                        [{file,"bad_lc.erl"},{line,7}]}|_]}} =
                 (catch id(bad_generator_bc(a))),
 
+            {'EXIT',{{bad_generator,a},
+                     [{?MODULE,_,_,
+                       [{file,"bad_lc.erl"},{line,10}]}|_]}} =
+                (catch id(bad_generator_mc(a))),
+
             %% List comprehensions with improper lists.
             {'EXIT',{{bad_generator,d},
                      [{?MODULE,_,_,
@@ -273,3 +278,6 @@ bad_generator(List) ->                          %Line 2
 bad_generator_bc(List) ->                       %Line 5
     << <<I:4>> ||                               %Line 6
         I <- List>>.                            %Line 7
+bad_generator_mc(List) ->                       %Line 8
+    #{I => ok ||                                %Line 9
+        I <- List}.                             %Line 10
diff --git a/lib/compiler/test/mc_SUITE.erl b/lib/compiler/test/mc_SUITE.erl
new file mode 100644
index 0000000000..21aa2c017e
--- /dev/null
+++ b/lib/compiler/test/mc_SUITE.erl
@@ -0,0 +1,272 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2023. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+%% Originally based on Per Gustafsson's test suite.
+%%
+
+-module(mc_SUITE).
+
+-export([all/0,suite/0,groups/0,init_per_suite/1,end_per_suite/1,
+	 init_per_group/2,end_per_group/2,
+         basic/1,duplicate_keys/1,mixed/1,
+         shadow/1,bad_generators/1]).
+
+-include_lib("common_test/include/ct.hrl").
+
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() ->
+    [{group,p}].
+
+groups() ->
+    [{p,test_lib:parallel(),
+      [basic,
+       duplicate_keys,
+       mixed,
+       shadow,
+       bad_generators]}].
+
+init_per_suite(Config) ->
+    test_lib:recompile(?MODULE),
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_group(_GroupName, Config) ->
+    Config.
+
+end_per_group(_GroupName, Config) ->
+    Config.
+
+basic(_Config) ->
+    mc_double(0),
+    mc_double(1),
+    mc_double(2),
+    mc_double(3),
+    mc_double(4),
+    mc_double(5),
+
+    mc_double(17),
+    mc_double(18),
+    mc_double(19),
+
+    mc_double(30),
+    mc_double(31),
+    mc_double(32),
+    mc_double(33),
+    mc_double(34),
+
+    mc_double(63),
+    mc_double(64),
+    mc_double(65),
+
+    mc_double(77),
+    mc_double(127),
+    mc_double(128),
+    mc_double(255),
+    mc_double(333),
+    mc_double(444),
+    mc_double(7777),
+    mc_double(8765),
+
+    %% Patterns that cannot possibly match.
+    #{} = #{K => V || K := [V]={V} <- id(#{a => [b]})},
+    #{} = #{K => V || [K] = 42 := V <- id(#{42 => whatever})},
+
+    %% Filtering.
+    Map = #{{a,1} => {a,b,c}, {b,42} => [1,2,3], c => [4,5,6], d => {x,y}},
+    [c, d] = lists:sort([K || K := _ <- Map, is_atom(K)]),
+    [{a,b,c}, [1,2,3]] = lists:sort([V || {_,_} := V <- Map]),
+    [1] = [H || {_,_} := [H|_] <- Map],
+    [c, {b,42}] = lists:sort([K || K := [_|_] <- Map]),
+
+    ok.
+
+mc_double(Size) ->
+    Seq = lists:seq(1, Size),
+    Map = #{{key,I} => I || I <- Seq},
+
+    MapDouble = #{K => 2 * V || K := V <- id(Map)},
+    MapDouble = maps:from_list([{{key,I}, 2 * I} || I <- Seq]),
+
+    OddKeys = lists:seq(1, Size, 2),
+    OddKeys = lists:sort([I || {key,I} := I <- Map,
+                               I rem 2 =/= 0]),
+
+    OddMap = #{I => [] || {key,I} := I <- Map,
+                          I rem 2 =/= 0},
+    OddMap = #{I => [] || {key,I} := I <- Map,
+                          id(I) rem 2 =/= 0},
+    OddKeys = lists:sort(maps:keys(OddMap)),
+
+    %% Test that map comprehensions works on iterators.
+    test_iterator(Map, 0),
+    test_iterator(Map, map_size(Map) div 3),
+    test_iterator(Map, map_size(Map) div 2),
+    test_iterator(Map, map_size(Map)),
+
+    ok.
+
+test_iterator(Map, N) ->
+    Iter0 = maps:iterator(Map),
+    {First,Iter} = grab(N, Iter0, []),
+    All = [{K,V} || K := V <- Iter] ++ First,
+    Map = maps:from_list(All),
+    ok.
+
+grab(0, Iter, Acc) ->
+    {Acc,Iter};
+grab(N, Iter0, Acc) ->
+    case maps:next(Iter0) of
+        none ->
+            {Acc,Iter0};
+        {K,V,Iter} ->
+            grab(N - 1, Iter, [{K,V}|Acc])
+    end.
+
+duplicate_keys(_Config) ->
+    #{x := b} = #{V => K || {K,V} <- [{a, x}, {b, x}]},
+
+    #{a := 4, b := 4} =
+        #{K => V || K <- [a,b],
+                    <<V>> <= <<1,2,3,4>>},
+    ok.
+
+mixed(_Config) ->
+    Map = id(#{1 => 10, 2 => 5, 3 => 88, 4 => 99, 5 => 36}),
+    Bin = << <<K:8,V:24>> || K := V <- Map >>,
+    Map = maps:from_list([{K,V} || <<K:8,V:24>> <= Bin]),
+
+    Atoms = [list_to_atom([C]) || C <- lists:seq($a, $z)],
+    Integers = lists:seq(1, 64),
+
+    mixed_1(Atoms, Integers),
+    mixed_2(Atoms, Integers),
+    mixed_3(Atoms, Integers),
+
+    sum_of_triangular_numbers(7),
+    sum_of_triangular_numbers(10),
+
+    ok.
+
+mixed_1(Atoms, Integers) ->
+    IntegerMap = #{N => [] || N <- Integers},
+    IntegerKeys = [N || N := [] <- IntegerMap],
+    Integers = lists:sort(IntegerKeys),
+    Combined = [{C,N} || C <- Atoms, N := [] <- IntegerMap],
+    Combined = [{C,N} || C <- Atoms, N := [] <- maps:iterator(IntegerMap)],
+    Combined = [{C,N} || C <- Atoms, N <- IntegerKeys],
+
+    ok.
+
+mixed_2(Atoms, Integers) ->
+    IntegerMap = #{N => [] || N <- Integers},
+    IntegerKeys = [N || N := [] <- IntegerMap],
+    Bin = << <<N:16>> || N := [] <- IntegerMap >>,
+    Integers = lists:sort(IntegerKeys),
+
+    Combined = [{C,N} || N := [] <- IntegerMap, C <- Atoms],
+    Combined = [{C,N} || N := [] <- maps:iterator(IntegerMap), C <- Atoms],
+    Combined = [{C,N} || <<N:16>> <= Bin, C <- Atoms],
+    Combined = [{C,N} || N <- IntegerKeys, C <- Atoms],
+
+    ok.
+
+mixed_3(Atoms, Integers) ->
+    Map = #{K => V || {K,V} <- lists:zip(Atoms, Integers, trim)},
+    Bin = << <<N:16>> || _ := N <- Map >>,
+    {TrimmedAtoms,TrimmedIntegers} = lists:unzip([{K,V} || K := V <- Map]),
+
+    Combined = lists:sort([{K,V} || K := _ <- Map, _ := V <- Map]),
+    Combined = lists:sort([{K,V} || K <- TrimmedAtoms, <<V:16>> <= Bin]),
+    Combined = lists:sort([{K,V} || K <- TrimmedAtoms, V <- TrimmedIntegers]),
+
+    ok.
+
+sum_of_triangular_numbers(N) ->
+    Sum = N * (N + 1) * (N + 2) div 6,
+    Maps = [#{I => I || I <- lists:seq(0, I)} || I <- lists:seq(0, N)],
+    Numbers = [I || M <- Maps, I := I <- M],
+    Numbers = lists:flatten([[I || I := I <- M] || M <- Maps]),
+    Sum = lists:sum([lists:sum([I || I := I <- M]) || M <- Maps]),
+    Sum = lists:sum(Numbers),
+    ok.
+
+shadow(_Config)->
+    Shadowed = nomatch,
+    _ = id(Shadowed),				%Eliminate warning.
+    Map = #{Shadowed => Shadowed+1 || Shadowed <- lists:seq(7, 9)},
+    #{7 := 8, 8 := 9, 9 := 10} = id(Map),
+    [8,9] = lists:sort([Shadowed || _ := Shadowed <- id(Map),
+                                    Shadowed < 10]),
+    ok.
+
+bad_generators(_Config) ->
+    %% Make sure that line numbers point out the generator.
+    case ?MODULE of
+        mc_inline_SUITE ->
+            ok;
+        _ ->
+            {'EXIT',{{bad_generator,a},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,4}]}|_]}} =
+                catch id(bad_generator(a)),
+
+            {'EXIT',{{bad_generator,a},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,7}]}|_]}} =
+                catch id(bad_generator_bc(a)),
+
+            {'EXIT',{{bad_generator,a},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,10}]}|_]}} =
+                catch id(bad_generator_mc(a)),
+
+            BadIterator = [16#ffff|#{}],
+
+            {'EXIT',{{bad_generator,BadIterator},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,4}]}|_]}} =
+                catch id(bad_generator(BadIterator)),
+
+            {'EXIT',{{bad_generator,BadIterator},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,7}]}|_]}} =
+                catch id(bad_generator_bc(BadIterator)),
+
+            {'EXIT',{{bad_generator,BadIterator},
+                     [{?MODULE,_,_,
+                       [{file,"bad_mc.erl"},{line,10}]}|_]}} =
+                catch id(bad_generator_mc(BadIterator))
+    end,
+    ok.
+
+id(I) -> I.
+
+-file("bad_mc.erl", 1).
+bad_generator(Map) ->                           %Line 2
+    [{K,V} ||                                   %Line 3
+        K := V <- Map].                         %Line 4
+bad_generator_bc(Map) ->                        %Line 5
+    << <<K:8,V:24>> ||                          %Line 6
+        K := V <- Map>>.                        %Line 7
+bad_generator_mc(Map) ->                        %Line 8
+    #{V => K ||                                 %Line 9
+        K := V <- Map}.                         %Line 10
diff --git a/lib/compiler/test/record_SUITE.erl b/lib/compiler/test/record_SUITE.erl
index f6c6c27965..34708a4d6d 100644
--- a/lib/compiler/test/record_SUITE.erl
+++ b/lib/compiler/test/record_SUITE.erl
@@ -238,6 +238,14 @@ record_test_2(Config) when is_list(Config) ->
 			 begin not is_record(X, foo) or
 				   is_reference(X) end],
 
+    Map = id(#{a => 1, b => #foo{a=2}, c => 3, d => #bar{d=4},
+               e => 5, f => #foo{a=6}, h => 7}),
+    [#foo{a=2},#foo{a=6}] = lists:sort([X || _ := X <- Map, is_record(X, foo)]),
+    [#bar{d=4}] = [X || _ := X <- Map, is_record(X, bar)],
+    [1,3,5,7,#foo{a=2},#foo{a=6}] =
+	lists:sort([X || _ := X <- Map, not is_record(X, bar)]),
+    [2,6] = lists:sort([A || _ := #foo{a=A} <- Map]),
+
     %% Call is_record/2 with illegal arguments.
     [] = [X || X <- [], is_record(t, id(X))],
     {'EXIT',{badarg,_}} = (catch [X || X <- [1], is_record(t, id(X))]),
-- 
2.35.3

Places

File 5609-v3_core-Handle-map-comprehensions.patch of Package erlang (Revision c681b8899ee889480c6f6ce3b6554db6)

Places