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