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

#!perl

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