ext/B/t/f_map.t

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