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