ext/B/t/f_map.t

   1 #!perl
   2
   3 BEGIN {
   4     chdir q(t);
   5     @INC = qw(../lib ../ext/B/t);
   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     }
  11     if ($Config::Config{'extensions'} !~ /\bData\/Dumper\b/) {
  12         print
  13             "1..0 # Skip: Data::Dumper was not built, needed by OptreeCheck\n";
  14         exit 0;
  15     }
  16     if (!$Config::Config{useperlio}) {
  17         print "1..0 # Skip -- need perlio to walk the optree\n";
  18         exit 0;
  19     }
  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);
  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