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