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