[p5sagit/p5-mst-13.2.git] / ext / B / t / f_map.t

#!perl

BEGIN {
    chdir q(t);
    @INC = qw(../lib ../ext/B/t);
    require q(./test.pl);
}
use OptreeCheck;
plan tests => 9;


=for gentest

# chunk: #!perl
# examples shamelessly snatched from perldoc -f map

=cut

=for gentest

# chunk: # translates a list of numbers to the corresponding characters.
@chars = map(chr, @nums);

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{@chars = map(chr, @nums); },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 475 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*nums] s
# 5  <1> rv2av[t7] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t8] lK
# 8      <#> gvsv[*_] s
# 9      <1> chr[t5] sK/1
#            goto 7
# a  <0> pushmark s
# b  <#> gv[*chars] s
# c  <1> rv2av[t2] lKRM*/1
# d  <2> aassign[t9] KS/COMMON
# e  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 559 (eval 15):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*nums) s
# 5  <1> rv2av[t4] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t5] lK
# 8      <$> gvsv(*_) s
# 9      <1> chr[t3] sK/1
#            goto 7
# a  <0> pushmark s
# b  <$> gv(*chars) s
# c  <1> rv2av[t1] lKRM*/1
# d  <2> aassign[t6] KS/COMMON
# e  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: %hash = map { getkey($_) => $_ } @array;

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map { getkey($_) => $_ } @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 476 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t8] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t9] lK
# 8      <0> enter l
# 9      <;> nextstate(main 475 (eval 10):1) v
# a      <0> pushmark s
# b      <0> pushmark s
# c      <#> gvsv[*_] s
# d      <#> gv[*getkey] s/EARLYCV
# e      <1> entersub[t5] lKS/TARG,1
# f      <#> gvsv[*_] s
# g      <@> list lK
# h      <@> leave lKP
#            goto 7
# i  <0> pushmark s
# j  <#> gv[*hash] s
# k  <1> rv2hv[t2] lKRM*/1
# l  <2> aassign[t10] KS/COMMON
# m  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 560 (eval 15):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t3] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t4] lK
# 8      <0> enter l
# 9      <;> nextstate(main 559 (eval 15):1) v
# a      <0> pushmark s
# b      <0> pushmark s
# c      <$> gvsv(*_) s
# d      <$> gv(*getkey) s/EARLYCV
# e      <1> entersub[t2] lKS/TARG,1
# f      <$> gvsv(*_) s
# g      <@> list lK
# h      <@> leave lKP
#            goto 7
# i  <0> pushmark s
# j  <$> gv(*hash) s
# k  <1> rv2hv[t1] lKRM*/1
# l  <2> aassign[t5] KS/COMMON
# m  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: {
    %hash = ();
    foreach $_ (@array) {
	$hash{getkey($_)} = $_;
    }
}

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{{ %hash = (); foreach $_ (@array) { $hash{getkey($_)} = $_; } } },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 478 (eval 10):1) v
# 2  <{> enterloop(next->u last->u redo->3) 
# 3  <;> nextstate(main 475 (eval 10):1) v
# 4  <0> pushmark s
# 5  <0> pushmark s
# 6  <#> gv[*hash] s
# 7  <1> rv2hv[t2] lKRM*/1
# 8  <2> aassign[t3] vKS
# 9  <;> nextstate(main 476 (eval 10):1) v
# a  <0> pushmark sM
# b  <#> gv[*array] s
# c  <1> rv2av[t6] sKRM/1
# d  <#> gv[*_] s
# e  <1> rv2gv sKRM/1
# f  <{> enteriter(next->q last->t redo->g) lKS
# r  <0> iter s
# s  <|> and(other->g) K/1
# g      <;> nextstate(main 475 (eval 10):1) v
# h      <#> gvsv[*_] s
# i      <#> gv[*hash] s
# j      <1> rv2hv sKR/1
# k      <0> pushmark s
# l      <#> gvsv[*_] s
# m      <#> gv[*getkey] s/EARLYCV
# n      <1> entersub[t10] sKS/TARG,1
# o      <2> helem sKRM*/2
# p      <2> sassign vKS/2
# q      <0> unstack s
#            goto r
# t  <2> leaveloop K/2
# u  <2> leaveloop K/2
# v  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 562 (eval 15):1) v
# 2  <{> enterloop(next->u last->u redo->3) 
# 3  <;> nextstate(main 559 (eval 15):1) v
# 4  <0> pushmark s
# 5  <0> pushmark s
# 6  <$> gv(*hash) s
# 7  <1> rv2hv[t1] lKRM*/1
# 8  <2> aassign[t2] vKS
# 9  <;> nextstate(main 560 (eval 15):1) v
# a  <0> pushmark sM
# b  <$> gv(*array) s
# c  <1> rv2av[t3] sKRM/1
# d  <$> gv(*_) s
# e  <1> rv2gv sKRM/1
# f  <{> enteriter(next->q last->t redo->g) lKS
# r  <0> iter s
# s  <|> and(other->g) K/1
# g      <;> nextstate(main 559 (eval 15):1) v
# h      <$> gvsv(*_) s
# i      <$> gv(*hash) s
# j      <1> rv2hv sKR/1
# k      <0> pushmark s
# l      <$> gvsv(*_) s
# m      <$> gv(*getkey) s/EARLYCV
# n      <1> entersub[t4] sKS/TARG,1
# o      <2> helem sKRM*/2
# p      <2> sassign vKS/2
# q      <0> unstack s
#            goto r
# t  <2> leaveloop K/2
# u  <2> leaveloop K/2
# v  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: #%hash = map {  "\L$_", 1  } @array;  # perl guesses EXPR.  wrong
%hash = map { +"\L$_", 1  } @array;  # perl guesses BLOCK. right

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map { +"\L$_", 1 } @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 476 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t7] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t9] lK
# 8      <0> pushmark s
# 9      <#> gvsv[*_] s
# a      <1> lc[t4] sK/1
# b      <@> stringify[t5] sK/1
# c      <$> const[IV 1] s
# d      <@> list lK
# -      <@> scope lK
#            goto 7
# e  <0> pushmark s
# f  <#> gv[*hash] s
# g  <1> rv2hv[t2] lKRM*/1
# h  <2> aassign[t10] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 560 (eval 15):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t4] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t5] lK
# 8      <0> pushmark s
# 9      <$> gvsv(*_) s
# a      <1> lc[t2] sK/1
# b      <@> stringify[t3] sK/1
# c      <$> const(IV 1) s
# d      <@> list lK
# -      <@> scope lK
#            goto 7
# e  <0> pushmark s
# f  <$> gv(*hash) s
# g  <1> rv2hv[t1] lKRM*/1
# h  <2> aassign[t6] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: %hash = map { ("\L$_", 1) } @array;  # this also works

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map { ("\L$_", 1) } @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 476 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t7] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t9] lK
# 8      <0> pushmark s
# 9      <#> gvsv[*_] s
# a      <1> lc[t4] sK/1
# b      <@> stringify[t5] sK/1
# c      <$> const[IV 1] s
# d      <@> list lKP
# -      <@> scope lK
#            goto 7
# e  <0> pushmark s
# f  <#> gv[*hash] s
# g  <1> rv2hv[t2] lKRM*/1
# h  <2> aassign[t10] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 560 (eval 15):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t4] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t5] lK
# 8      <0> pushmark s
# 9      <$> gvsv(*_) s
# a      <1> lc[t2] sK/1
# b      <@> stringify[t3] sK/1
# c      <$> const(IV 1) s
# d      <@> list lKP
# -      <@> scope lK
#            goto 7
# e  <0> pushmark s
# f  <$> gv(*hash) s
# g  <1> rv2hv[t1] lKRM*/1
# h  <2> aassign[t6] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: %hash = map {  lc($_), 1  } @array;  # as does this.

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map { lc($_), 1 } @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 476 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t6] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t8] lK
# 8      <0> pushmark s
# 9      <#> gvsv[*_] s
# a      <1> lc[t4] sK/1
# b      <$> const[IV 1] s
# c      <@> list lK
# -      <@> scope lK
#            goto 7
# d  <0> pushmark s
# e  <#> gv[*hash] s
# f  <1> rv2hv[t2] lKRM*/1
# g  <2> aassign[t9] KS/COMMON
# h  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 589 (eval 26):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t3] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t4] lK
# 8      <0> pushmark s
# 9      <$> gvsv(*_) s
# a      <1> lc[t2] sK/1
# b      <$> const(IV 1) s
# c      <@> list lK
# -      <@> scope lK
#            goto 7
# d  <0> pushmark s
# e  <$> gv(*hash) s
# f  <1> rv2hv[t1] lKRM*/1
# g  <2> aassign[t5] KS/COMMON
# h  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: %hash = map +( lc($_), 1 ), @array;  # this is EXPR and works!

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map +( lc($_), 1 ), @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 475 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t6] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t7] lK
# 8      <0> pushmark s
# 9      <#> gvsv[*_] s
# a      <1> lc[t4] sK/1
# b      <$> const[IV 1] s
# c      <@> list lKP
#            goto 7
# d  <0> pushmark s
# e  <#> gv[*hash] s
# f  <1> rv2hv[t2] lKRM*/1
# g  <2> aassign[t8] KS/COMMON
# h  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 593 (eval 28):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t3] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t4] lK
# 8      <0> pushmark s
# 9      <$> gvsv(*_) s
# a      <1> lc[t2] sK/1
# b      <$> const(IV 1) s
# c      <@> list lKP
#            goto 7
# d  <0> pushmark s
# e  <$> gv(*hash) s
# f  <1> rv2hv[t1] lKRM*/1
# g  <2> aassign[t5] KS/COMMON
# h  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: %hash = map  ( lc($_), 1 ), @array;  # evaluates to (1, @array)

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{%hash = map ( lc($_), 1 ), @array; },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 475 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <0> pushmark s
# 5  <$> const[IV 1] sM
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t5] lK
# 8      <#> gvsv[*_] s
# 9      <1> lc[t4] sK/1
#            goto 7
# a  <0> pushmark s
# b  <#> gv[*hash] s
# c  <1> rv2hv[t2] lKRM*/1
# d  <2> aassign[t6] KS/COMMON
# e  <#> gv[*array] s
# f  <1> rv2av[t8] K/1
# g  <@> list K
# h  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 597 (eval 30):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <0> pushmark s
# 5  <$> const(IV 1) sM
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t3] lK
# 8      <$> gvsv(*_) s
# 9      <1> lc[t2] sK/1
#            goto 7
# a  <0> pushmark s
# b  <$> gv(*hash) s
# c  <1> rv2hv[t1] lKRM*/1
# d  <2> aassign[t4] KS/COMMON
# e  <$> gv(*array) s
# f  <1> rv2av[t5] K/1
# g  <@> list K
# h  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


=for gentest

# chunk: @hashes = map +{ lc($_), 1 }, @array # EXPR, so needs , at end

=cut

checkOptree(note   => q{},
	    bcopts => q{-exec},
	    code   => q{@hashes = map +{ lc($_), 1 }, @array },
	    expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 475 (eval 10):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*array] s
# 5  <1> rv2av[t6] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t7] lK
# 8      <0> pushmark s
# 9      <#> gvsv[*_] s
# a      <1> lc[t4] sK/1
# b      <$> const[IV 1] s
# c      <@> anonhash sKRM/1
# d      <1> srefgen sK/1
#            goto 7
# e  <0> pushmark s
# f  <#> gv[*hashes] s
# g  <1> rv2av[t2] lKRM*/1
# h  <2> aassign[t8] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 601 (eval 32):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*array) s
# 5  <1> rv2av[t3] lKM/1
# 6  <@> mapstart lK
# 7  <|> mapwhile(other->8)[t4] lK
# 8      <0> pushmark s
# 9      <$> gvsv(*_) s
# a      <1> lc[t2] sK/1
# b      <$> const(IV 1) s
# c      <@> anonhash sKRM/1
# d      <1> srefgen sK/1
#            goto 7
# e  <0> pushmark s
# f  <$> gv(*hashes) s
# g  <1> rv2av[t1] lKRM*/1
# h  <2> aassign[t5] KS/COMMON
# i  <1> leavesub[1 ref] K/REFC,1
EONT_EONT
Commit	Line	Data
cc02ea56	1	#!perl
	2
	3	BEGIN {
	4	chdir q(t);
	5	@INC = qw(../lib ../ext/B/t);
	6	require q(./test.pl);
	7	}
	8	use OptreeCheck;
	9	plan tests => 9;
	10
	11
	12	=for gentest
	13
	14	# chunk: #!perl
	15	# examples shamelessly snatched from perldoc -f map
	16
	17	=cut
	18
	19	=for gentest
	20
	21	# chunk: # translates a list of numbers to the corresponding characters.
	22	@chars = map(chr, @nums);
	23
	24	=cut
	25
	26	checkOptree(note => q{},
	27	bcopts => q{-exec},
	28	code => q{@chars = map(chr, @nums); },
	29	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	30	# 1 <;> nextstate(main 475 (eval 10):1) v
	31	# 2 <0> pushmark s
	32	# 3 <0> pushmark s
	33	# 4 <#> gv[*nums] s
	34	# 5 <1> rv2av[t7] lKM/1
	35	# 6 <@> mapstart lK
	36	# 7 <\|> mapwhile(other->8)[t8] lK
	37	# 8 <#> gvsv[*_] s
	38	# 9 <1> chr[t5] sK/1
	39	# goto 7
	40	# a <0> pushmark s
	41	# b <#> gv[*chars] s
	42	# c <1> rv2av[t2] lKRM*/1
	43	# d <2> aassign[t9] KS/COMMON
	44	# e <1> leavesub[1 ref] K/REFC,1
	45	EOT_EOT
	46	# 1 <;> nextstate(main 559 (eval 15):1) v
	47	# 2 <0> pushmark s
	48	# 3 <0> pushmark s
	49	# 4 <$> gv(*nums) s
	50	# 5 <1> rv2av[t4] lKM/1
	51	# 6 <@> mapstart lK
	52	# 7 <\|> mapwhile(other->8)[t5] lK
	53	# 8 <$> gvsv(*_) s
	54	# 9 <1> chr[t3] sK/1
	55	# goto 7
	56	# a <0> pushmark s
	57	# b <$> gv(*chars) s
	58	# c <1> rv2av[t1] lKRM*/1
	59	# d <2> aassign[t6] KS/COMMON
	60	# e <1> leavesub[1 ref] K/REFC,1
	61	EONT_EONT
	62
	63
	64	=for gentest
65
66	# chunk: %hash = map { getkey($_) => $_ } @array;
67
68	=cut
69
70	checkOptree(note => q{},
71	bcopts => q{-exec},
72	code => q{%hash = map { getkey($_) => $_ } @array; },
73	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
74	# 1 <;> nextstate(main 476 (eval 10):1) v
75	# 2 <0> pushmark s
76	# 3 <0> pushmark s
77	# 4 <#> gv[*array] s
78	# 5 <1> rv2av[t8] lKM/1
79	# 6 <@> mapstart lK*
80	# 7 <\|> mapwhile(other->8)[t9] lK
81	# 8 <0> enter l
82	# 9 <;> nextstate(main 475 (eval 10):1) v
83	# a <0> pushmark s
84	# b <0> pushmark s
85	# c <#> gvsv[*_] s
86	# d <#> gv[*getkey] s/EARLYCV
87	# e <1> entersub[t5] lKS/TARG,1
88	# f <#> gvsv[*_] s
89	# g <@> list lK
90	# h <@> leave lKP
91	# goto 7
92	# i <0> pushmark s
93	# j <#> gv[*hash] s
94	# k <1> rv2hv[t2] lKRM*/1
95	# l <2> aassign[t10] KS/COMMON
96	# m <1> leavesub[1 ref] K/REFC,1
97	EOT_EOT
98	# 1 <;> nextstate(main 560 (eval 15):1) v
99	# 2 <0> pushmark s
100	# 3 <0> pushmark s
101	# 4 <$> gv(*array) s
102	# 5 <1> rv2av[t3] lKM/1
103	# 6 <@> mapstart lK*
104	# 7 <\|> mapwhile(other->8)[t4] lK
105	# 8 <0> enter l
106	# 9 <;> nextstate(main 559 (eval 15):1) v
107	# a <0> pushmark s
108	# b <0> pushmark s
109	# c <$> gvsv(*_) s
110	# d <$> gv(*getkey) s/EARLYCV
111	# e <1> entersub[t2] lKS/TARG,1
112	# f <$> gvsv(*_) s
113	# g <@> list lK
114	# h <@> leave lKP
115	# goto 7
116	# i <0> pushmark s
117	# j <$> gv(*hash) s
118	# k <1> rv2hv[t1] lKRM*/1
119	# l <2> aassign[t5] KS/COMMON
120	# m <1> leavesub[1 ref] K/REFC,1
121	EONT_EONT
122
123
124	=for gentest
125
126	# chunk: {
127	%hash = ();
128	foreach $_ (@array) {
129	$hash{getkey($_)} = $_;
130	}
131	}
132
133	=cut
134
135	checkOptree(note => q{},
136	bcopts => q{-exec},
137	code => q{{ %hash = (); foreach $_ (@array) { $hash{getkey($_)} = $_; } } },
138	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
139	# 1 <;> nextstate(main 478 (eval 10):1) v
140	# 2 <{> enterloop(next->u last->u redo->3)
141	# 3 <;> nextstate(main 475 (eval 10):1) v
142	# 4 <0> pushmark s
143	# 5 <0> pushmark s
144	# 6 <#> gv[*hash] s
145	# 7 <1> rv2hv[t2] lKRM*/1
146	# 8 <2> aassign[t3] vKS
147	# 9 <;> nextstate(main 476 (eval 10):1) v
148	# a <0> pushmark sM
149	# b <#> gv[*array] s
150	# c <1> rv2av[t6] sKRM/1
151	# d <#> gv[*_] s
152	# e <1> rv2gv sKRM/1
153	# f <{> enteriter(next->q last->t redo->g) lKS
154	# r <0> iter s
155	# s <\|> and(other->g) K/1
156	# g <;> nextstate(main 475 (eval 10):1) v
157	# h <#> gvsv[*_] s
158	# i <#> gv[*hash] s
159	# j <1> rv2hv sKR/1
160	# k <0> pushmark s
161	# l <#> gvsv[*_] s
162	# m <#> gv[*getkey] s/EARLYCV
163	# n <1> entersub[t10] sKS/TARG,1
164	# o <2> helem sKRM*/2
165	# p <2> sassign vKS/2
166	# q <0> unstack s
167	# goto r
168	# t <2> leaveloop K/2
169	# u <2> leaveloop K/2
170	# v <1> leavesub[1 ref] K/REFC,1
171	EOT_EOT
172	# 1 <;> nextstate(main 562 (eval 15):1) v
173	# 2 <{> enterloop(next->u last->u redo->3)
174	# 3 <;> nextstate(main 559 (eval 15):1) v
175	# 4 <0> pushmark s
176	# 5 <0> pushmark s
177	# 6 <$> gv(*hash) s
178	# 7 <1> rv2hv[t1] lKRM*/1
179	# 8 <2> aassign[t2] vKS
180	# 9 <;> nextstate(main 560 (eval 15):1) v
181	# a <0> pushmark sM
182	# b <$> gv(*array) s
183	# c <1> rv2av[t3] sKRM/1
184	# d <$> gv(*_) s
185	# e <1> rv2gv sKRM/1
186	# f <{> enteriter(next->q last->t redo->g) lKS
187	# r <0> iter s
188	# s <\|> and(other->g) K/1
189	# g <;> nextstate(main 559 (eval 15):1) v
190	# h <$> gvsv(*_) s
191	# i <$> gv(*hash) s
192	# j <1> rv2hv sKR/1
193	# k <0> pushmark s
194	# l <$> gvsv(*_) s
195	# m <$> gv(*getkey) s/EARLYCV
196	# n <1> entersub[t4] sKS/TARG,1
197	# o <2> helem sKRM*/2
198	# p <2> sassign vKS/2
199	# q <0> unstack s
200	# goto r
201	# t <2> leaveloop K/2
202	# u <2> leaveloop K/2
203	# v <1> leavesub[1 ref] K/REFC,1
204	EONT_EONT
205
206
207	=for gentest
208
209	# chunk: #%hash = map { "\L$_", 1 } @array; # perl guesses EXPR. wrong
210	%hash = map { +"\L$_", 1 } @array; # perl guesses BLOCK. right
211
212	=cut
213
214	checkOptree(note => q{},
215	bcopts => q{-exec},
216	code => q{%hash = map { +"\L$_", 1 } @array; },
217	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
218	# 1 <;> nextstate(main 476 (eval 10):1) v
219	# 2 <0> pushmark s
220	# 3 <0> pushmark s
221	# 4 <#> gv[*array] s
222	# 5 <1> rv2av[t7] lKM/1
223	# 6 <@> mapstart lK*
224	# 7 <\|> mapwhile(other->8)[t9] lK
225	# 8 <0> pushmark s
226	# 9 <#> gvsv[*_] s
227	# a <1> lc[t4] sK/1
228	# b <@> stringify[t5] sK/1
229	# c <$> const[IV 1] s
230	# d <@> list lK
231	# - <@> scope lK
232	# goto 7
233	# e <0> pushmark s
234	# f <#> gv[*hash] s
235	# g <1> rv2hv[t2] lKRM*/1
236	# h <2> aassign[t10] KS/COMMON
237	# i <1> leavesub[1 ref] K/REFC,1
238	EOT_EOT
239	# 1 <;> nextstate(main 560 (eval 15):1) v
240	# 2 <0> pushmark s
241	# 3 <0> pushmark s
242	# 4 <$> gv(*array) s
243	# 5 <1> rv2av[t4] lKM/1
244	# 6 <@> mapstart lK*
245	# 7 <\|> mapwhile(other->8)[t5] lK
246	# 8 <0> pushmark s
247	# 9 <$> gvsv(*_) s
248	# a <1> lc[t2] sK/1
249	# b <@> stringify[t3] sK/1
250	# c <$> const(IV 1) s
251	# d <@> list lK
252	# - <@> scope lK
253	# goto 7
254	# e <0> pushmark s
255	# f <$> gv(*hash) s
256	# g <1> rv2hv[t1] lKRM*/1
257	# h <2> aassign[t6] KS/COMMON
258	# i <1> leavesub[1 ref] K/REFC,1
259	EONT_EONT
260
261
262	=for gentest
263
264	# chunk: %hash = map { ("\L$_", 1) } @array; # this also works
265
266	=cut
267
268	checkOptree(note => q{},
269	bcopts => q{-exec},
270	code => q{%hash = map { ("\L$_", 1) } @array; },
271	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
272	# 1 <;> nextstate(main 476 (eval 10):1) v
273	# 2 <0> pushmark s
274	# 3 <0> pushmark s
275	# 4 <#> gv[*array] s
276	# 5 <1> rv2av[t7] lKM/1
277	# 6 <@> mapstart lK*
278	# 7 <\|> mapwhile(other->8)[t9] lK
279	# 8 <0> pushmark s
280	# 9 <#> gvsv[*_] s
281	# a <1> lc[t4] sK/1
282	# b <@> stringify[t5] sK/1
283	# c <$> const[IV 1] s
284	# d <@> list lKP
285	# - <@> scope lK
286	# goto 7
287	# e <0> pushmark s
288	# f <#> gv[*hash] s
289	# g <1> rv2hv[t2] lKRM*/1
290	# h <2> aassign[t10] KS/COMMON
291	# i <1> leavesub[1 ref] K/REFC,1
292	EOT_EOT
293	# 1 <;> nextstate(main 560 (eval 15):1) v
294	# 2 <0> pushmark s
295	# 3 <0> pushmark s
296	# 4 <$> gv(*array) s
297	# 5 <1> rv2av[t4] lKM/1
298	# 6 <@> mapstart lK*
299	# 7 <\|> mapwhile(other->8)[t5] lK
300	# 8 <0> pushmark s
301	# 9 <$> gvsv(*_) s
302	# a <1> lc[t2] sK/1
303	# b <@> stringify[t3] sK/1
304	# c <$> const(IV 1) s
305	# d <@> list lKP
306	# - <@> scope lK
307	# goto 7
308	# e <0> pushmark s
309	# f <$> gv(*hash) s
310	# g <1> rv2hv[t1] lKRM*/1
311	# h <2> aassign[t6] KS/COMMON
312	# i <1> leavesub[1 ref] K/REFC,1
313	EONT_EONT
314
315
316	=for gentest
317
318	# chunk: %hash = map { lc($_), 1 } @array; # as does this.
319
320	=cut
321
322	checkOptree(note => q{},
323	bcopts => q{-exec},
324	code => q{%hash = map { lc($_), 1 } @array; },
325	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
326	# 1 <;> nextstate(main 476 (eval 10):1) v
327	# 2 <0> pushmark s
328	# 3 <0> pushmark s
329	# 4 <#> gv[*array] s
330	# 5 <1> rv2av[t6] lKM/1
331	# 6 <@> mapstart lK*
332	# 7 <\|> mapwhile(other->8)[t8] lK
333	# 8 <0> pushmark s
334	# 9 <#> gvsv[*_] s
335	# a <1> lc[t4] sK/1
336	# b <$> const[IV 1] s
337	# c <@> list lK
338	# - <@> scope lK
339	# goto 7
340	# d <0> pushmark s
341	# e <#> gv[*hash] s
342	# f <1> rv2hv[t2] lKRM*/1
343	# g <2> aassign[t9] KS/COMMON
344	# h <1> leavesub[1 ref] K/REFC,1
345	EOT_EOT
346	# 1 <;> nextstate(main 589 (eval 26):1) v
347	# 2 <0> pushmark s
348	# 3 <0> pushmark s
349	# 4 <$> gv(*array) s
350	# 5 <1> rv2av[t3] lKM/1
351	# 6 <@> mapstart lK*
352	# 7 <\|> mapwhile(other->8)[t4] lK
353	# 8 <0> pushmark s
354	# 9 <$> gvsv(*_) s
355	# a <1> lc[t2] sK/1
356	# b <$> const(IV 1) s
357	# c <@> list lK
358	# - <@> scope lK
359	# goto 7
360	# d <0> pushmark s
361	# e <$> gv(*hash) s
362	# f <1> rv2hv[t1] lKRM*/1
363	# g <2> aassign[t5] KS/COMMON
364	# h <1> leavesub[1 ref] K/REFC,1
365	EONT_EONT
366
367
368	=for gentest
369
370	# chunk: %hash = map +( lc($_), 1 ), @array; # this is EXPR and works!
371
372	=cut
373
374	checkOptree(note => q{},
375	bcopts => q{-exec},
376	code => q{%hash = map +( lc($_), 1 ), @array; },
377	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
378	# 1 <;> nextstate(main 475 (eval 10):1) v
379	# 2 <0> pushmark s
380	# 3 <0> pushmark s
381	# 4 <#> gv[*array] s
382	# 5 <1> rv2av[t6] lKM/1
383	# 6 <@> mapstart lK
384	# 7 <\|> mapwhile(other->8)[t7] lK
385	# 8 <0> pushmark s
386	# 9 <#> gvsv[*_] s
387	# a <1> lc[t4] sK/1
388	# b <$> const[IV 1] s
389	# c <@> list lKP
390	# goto 7
391	# d <0> pushmark s
392	# e <#> gv[*hash] s
393	# f <1> rv2hv[t2] lKRM*/1
394	# g <2> aassign[t8] KS/COMMON
395	# h <1> leavesub[1 ref] K/REFC,1
396	EOT_EOT
397	# 1 <;> nextstate(main 593 (eval 28):1) v
398	# 2 <0> pushmark s
399	# 3 <0> pushmark s
400	# 4 <$> gv(*array) s
401	# 5 <1> rv2av[t3] lKM/1
402	# 6 <@> mapstart lK
403	# 7 <\|> mapwhile(other->8)[t4] lK
404	# 8 <0> pushmark s
405	# 9 <$> gvsv(*_) s
406	# a <1> lc[t2] sK/1
407	# b <$> const(IV 1) s
408	# c <@> list lKP
409	# goto 7
410	# d <0> pushmark s
411	# e <$> gv(*hash) s
412	# f <1> rv2hv[t1] lKRM*/1
413	# g <2> aassign[t5] KS/COMMON
414	# h <1> leavesub[1 ref] K/REFC,1
415	EONT_EONT
416
417
418	=for gentest
419
420	# chunk: %hash = map ( lc($_), 1 ), @array; # evaluates to (1, @array)
421
422	=cut
423
424	checkOptree(note => q{},
425	bcopts => q{-exec},
426	code => q{%hash = map ( lc($_), 1 ), @array; },
427	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
428	# 1 <;> nextstate(main 475 (eval 10):1) v
429	# 2 <0> pushmark s
430	# 3 <0> pushmark s
431	# 4 <0> pushmark s
432	# 5 <$> const[IV 1] sM
433	# 6 <@> mapstart lK
434	# 7 <\|> mapwhile(other->8)[t5] lK
435	# 8 <#> gvsv[*_] s
436	# 9 <1> lc[t4] sK/1
437	# goto 7
438	# a <0> pushmark s
439	# b <#> gv[*hash] s
440	# c <1> rv2hv[t2] lKRM*/1
441	# d <2> aassign[t6] KS/COMMON
442	# e <#> gv[*array] s
443	# f <1> rv2av[t8] K/1
444	# g <@> list K
445	# h <1> leavesub[1 ref] K/REFC,1
446	EOT_EOT
447	# 1 <;> nextstate(main 597 (eval 30):1) v
448	# 2 <0> pushmark s
449	# 3 <0> pushmark s
450	# 4 <0> pushmark s
451	# 5 <$> const(IV 1) sM
452	# 6 <@> mapstart lK
453	# 7 <\|> mapwhile(other->8)[t3] lK
454	# 8 <$> gvsv(*_) s
455	# 9 <1> lc[t2] sK/1
456	# goto 7
457	# a <0> pushmark s
458	# b <$> gv(*hash) s
459	# c <1> rv2hv[t1] lKRM*/1
460	# d <2> aassign[t4] KS/COMMON
461	# e <$> gv(*array) s
462	# f <1> rv2av[t5] K/1
463	# g <@> list K
464	# h <1> leavesub[1 ref] K/REFC,1
465	EONT_EONT
466
467
468	=for gentest
469
470	# chunk: @hashes = map +{ lc($_), 1 }, @array # EXPR, so needs , at end
471
472	=cut
473
474	checkOptree(note => q{},
475	bcopts => q{-exec},
476	code => q{@hashes = map +{ lc($_), 1 }, @array },
477	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
478	# 1 <;> nextstate(main 475 (eval 10):1) v
479	# 2 <0> pushmark s
480	# 3 <0> pushmark s
481	# 4 <#> gv[*array] s
482	# 5 <1> rv2av[t6] lKM/1
483	# 6 <@> mapstart lK
484	# 7 <\|> mapwhile(other->8)[t7] lK
485	# 8 <0> pushmark s
486	# 9 <#> gvsv[*_] s
487	# a <1> lc[t4] sK/1
488	# b <$> const[IV 1] s
489	# c <@> anonhash sKRM/1
490	# d <1> srefgen sK/1
491	# goto 7
492	# e <0> pushmark s
493	# f <#> gv[*hashes] s
494	# g <1> rv2av[t2] lKRM*/1
495	# h <2> aassign[t8] KS/COMMON
496	# i <1> leavesub[1 ref] K/REFC,1
497	EOT_EOT
498	# 1 <;> nextstate(main 601 (eval 32):1) v
499	# 2 <0> pushmark s
500	# 3 <0> pushmark s
501	# 4 <$> gv(*array) s
502	# 5 <1> rv2av[t3] lKM/1
503	# 6 <@> mapstart lK
504	# 7 <\|> mapwhile(other->8)[t4] lK
505	# 8 <0> pushmark s
506	# 9 <$> gvsv(*_) s
507	# a <1> lc[t2] sK/1
508	# b <$> const(IV 1) s
509	# c <@> anonhash sKRM/1
510	# d <1> srefgen sK/1
511	# goto 7
512	# e <0> pushmark s
513	# f <$> gv(*hashes) s
514	# g <1> rv2av[t1] lKRM*/1
515	# h <2> aassign[t5] KS/COMMON
516	# i <1> leavesub[1 ref] K/REFC,1
517	EONT_EONT