ext/B/t/optree_varinit.t

   1 #!perl
   2
   3 BEGIN {
   4     if ($ENV{PERL_CORE}){
   5         chdir('t') if -d 't';
   6         @INC = ('.', '../lib', '../ext/B/t');
   7     } else {
   8         unshift @INC, 't';
   9         push @INC, "../../t";
  10     }
  11     require Config;
  12     if (($Config::Config{'extensions'} !~ /\bB\b/) ){
  13         print "1..0 # Skip -- Perl configured without B module\n";
  14         exit 0;
  15     }
  16     # require 'test.pl'; # now done by OptreeCheck
  17 }
  18 use OptreeCheck;
  19 use Config;
  20 plan tests      => 22;
  21 SKIP: {
  22 skip "no perlio in this build", 22 unless $Config::Config{useperlio};
  23
  24 pass("OPTIMIZER TESTS - VAR INITIALIZATION");
  25
  26 my @open_todo;
  27 sub open_todo {
  28     if (((caller 0)[10]||{})->{open}) {
  29         @open_todo = (skip => "\$^OPEN is set");
  30     }
  31 }
  32 open_todo;
  33
  34 checkOptree ( name      => 'sub {my $a}',
  35               bcopts    => '-exec',
  36               code      => sub {my $a},
  37               @open_todo,
  38               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  39 # 1  <;> nextstate(main 45 optree.t:23) v
  40 # 2  <0> padsv[$a:45,46] M/LVINTRO
  41 # 3  <1> leavesub[1 ref] K/REFC,1
  42 EOT_EOT
  43 # 1  <;> nextstate(main 45 optree.t:23) v
  44 # 2  <0> padsv[$a:45,46] M/LVINTRO
  45 # 3  <1> leavesub[1 ref] K/REFC,1
  46 EONT_EONT
  47
  48 checkOptree ( name      => '-exec sub {my $a}',
  49               bcopts    => '-exec',
  50               code      => sub {my $a},
  51               @open_todo,
  52               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  53 # 1  <;> nextstate(main 49 optree.t:52) v
  54 # 2  <0> padsv[$a:49,50] M/LVINTRO
  55 # 3  <1> leavesub[1 ref] K/REFC,1
  56 EOT_EOT
  57 # 1  <;> nextstate(main 49 optree.t:45) v
  58 # 2  <0> padsv[$a:49,50] M/LVINTRO
  59 # 3  <1> leavesub[1 ref] K/REFC,1
  60 EONT_EONT
  61
  62 checkOptree ( name      => 'sub {our $a}',
  63               bcopts    => '-exec',
  64               code      => sub {our $a},
  65               @open_todo,
  66               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  67 1  <;> nextstate(main 21 optree.t:47) v
  68 2  <#> gvsv[*a] s/OURINTR
  69 3  <1> leavesub[1 ref] K/REFC,1
  70 EOT_EOT
  71 # 1  <;> nextstate(main 51 optree.t:56) v
  72 # 2  <$> gvsv(*a) s/OURINTR
  73 # 3  <1> leavesub[1 ref] K/REFC,1
  74 EONT_EONT
  75
  76 checkOptree ( name      => 'sub {local $a}',
  77               bcopts    => '-exec',
  78               code      => sub {local $a},
  79               @open_todo,
  80               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  81 1  <;> nextstate(main 23 optree.t:57) v:{
  82 2  <#> gvsv[*a] s/LVINTRO
  83 3  <1> leavesub[1 ref] K/REFC,1
  84 EOT_EOT
  85 # 1  <;> nextstate(main 53 optree.t:67) v:{
  86 # 2  <$> gvsv(*a) s/LVINTRO
  87 # 3  <1> leavesub[1 ref] K/REFC,1
  88 EONT_EONT
  89
  90 checkOptree ( name      => 'my $a',
  91               prog      => 'my $a',
  92               bcopts    => '-basic',
  93               @open_todo,
  94               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  95 # 4  <@> leave[1 ref] vKP/REFC ->(end)
  96 # 1     <0> enter ->2
  97 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
  98 # 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
  99 EOT_EOT
 100 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 101 # 1     <0> enter ->2
 102 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 103 # 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
 104 EONT_EONT
 105
 106 checkOptree ( name      => 'our $a',
 107               prog      => 'our $a',
 108               bcopts    => '-basic',
 109               @open_todo,
 110               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 111 4  <@> leave[1 ref] vKP/REFC ->(end)
 112 1     <0> enter ->2
 113 2     <;> nextstate(main 1 -e:1) v:{ ->3
 114 -     <1> ex-rv2sv vK/17 ->4
 115 3        <#> gvsv[*a] s/OURINTR ->4
 116 EOT_EOT
 117 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 118 # 1     <0> enter ->2
 119 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 120 # -     <1> ex-rv2sv vK/17 ->4
 121 # 3        <$> gvsv(*a) s/OURINTR ->4
 122 EONT_EONT
 123
 124 checkOptree ( name      => 'local $a',
 125               prog      => 'local $a',
 126               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 127               bcopts    => '-basic',
 128               @open_todo,
 129               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 130 4  <@> leave[1 ref] vKP/REFC ->(end)
 131 1     <0> enter ->2
 132 2     <;> nextstate(main 1 -e:1) v:{ ->3
 133 -     <1> ex-rv2sv vKM/129 ->4
 134 3        <#> gvsv[*a] s/LVINTRO ->4
 135 EOT_EOT
 136 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 137 # 1     <0> enter ->2
 138 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 139 # -     <1> ex-rv2sv vKM/129 ->4
 140 # 3        <$> gvsv(*a) s/LVINTRO ->4
 141 EONT_EONT
 142
 143 pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
 144
 145 checkOptree ( name      => 'sub {my $a=undef}',
 146               code      => sub {my $a=undef},
 147               bcopts    => '-basic',
 148               @open_todo,
 149               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 150 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 151 -     <@> lineseq KP ->5
 152 1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
 153 4        <2> sassign sKS/2 ->5
 154 2           <0> undef s ->3
 155 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
 156 EOT_EOT
 157 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 158 # -     <@> lineseq KP ->5
 159 # 1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
 160 # 4        <2> sassign sKS/2 ->5
 161 # 2           <0> undef s ->3
 162 # 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
 163 EONT_EONT
 164
 165 checkOptree ( name      => 'sub {our $a=undef}',
 166               code      => sub {our $a=undef},
 167               note      => 'the global must be reset',
 168               bcopts    => '-basic',
 169               @open_todo,
 170               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 171 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 172 -     <@> lineseq KP ->5
 173 1        <;> nextstate(main 26 optree.t:109) v:{ ->2
 174 4        <2> sassign sKS/2 ->5
 175 2           <0> undef s ->3
 176 -           <1> ex-rv2sv sKRM*/17 ->4
 177 3              <#> gvsv[*a] s/OURINTR ->4
 178 EOT_EOT
 179 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 180 # -     <@> lineseq KP ->5
 181 # 1        <;> nextstate(main 446 optree_varinit.t:137) v:{ ->2
 182 # 4        <2> sassign sKS/2 ->5
 183 # 2           <0> undef s ->3
 184 # -           <1> ex-rv2sv sKRM*/17 ->4
 185 # 3              <$> gvsv(*a) s/OURINTR ->4
 186 EONT_EONT
 187
 188 checkOptree ( name      => 'sub {local $a=undef}',
 189               code      => sub {local $a=undef},
 190               note      => 'local not used enough to bother',
 191               bcopts    => '-basic',
 192               @open_todo,
 193               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 194 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 195 -     <@> lineseq KP ->5
 196 1        <;> nextstate(main 28 optree.t:122) v:{ ->2
 197 4        <2> sassign sKS/2 ->5
 198 2           <0> undef s ->3
 199 -           <1> ex-rv2sv sKRM*/129 ->4
 200 3              <#> gvsv[*a] s/LVINTRO ->4
 201 EOT_EOT
 202 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 203 # -     <@> lineseq KP ->5
 204 # 1        <;> nextstate(main 58 optree.t:141) v:{ ->2
 205 # 4        <2> sassign sKS/2 ->5
 206 # 2           <0> undef s ->3
 207 # -           <1> ex-rv2sv sKRM*/129 ->4
 208 # 3              <$> gvsv(*a) s/LVINTRO ->4
 209 EONT_EONT
 210
 211 checkOptree ( name      => 'my $a=undef',
 212               prog      => 'my $a=undef',
 213               bcopts    => '-basic',
 214               @open_todo,
 215               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 216 6  <@> leave[1 ref] vKP/REFC ->(end)
 217 1     <0> enter ->2
 218 2     <;> nextstate(main 1 -e:1) v:{ ->3
 219 5     <2> sassign vKS/2 ->6
 220 3        <0> undef s ->4
 221 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
 222 EOT_EOT
 223 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 224 # 1     <0> enter ->2
 225 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 226 # 5     <2> sassign vKS/2 ->6
 227 # 3        <0> undef s ->4
 228 # 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
 229 EONT_EONT
 230
 231 checkOptree ( name      => 'our $a=undef',
 232               prog      => 'our $a=undef',
 233               note      => 'global must be reassigned',
 234               bcopts    => '-basic',
 235               @open_todo,
 236               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 237 6  <@> leave[1 ref] vKP/REFC ->(end)
 238 1     <0> enter ->2
 239 2     <;> nextstate(main 1 -e:1) v:{ ->3
 240 5     <2> sassign vKS/2 ->6
 241 3        <0> undef s ->4
 242 -        <1> ex-rv2sv sKRM*/17 ->5
 243 4           <#> gvsv[*a] s/OURINTR ->5
 244 EOT_EOT
 245 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 246 # 1     <0> enter ->2
 247 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 248 # 5     <2> sassign vKS/2 ->6
 249 # 3        <0> undef s ->4
 250 # -        <1> ex-rv2sv sKRM*/17 ->5
 251 # 4           <$> gvsv(*a) s/OURINTR ->5
 252 EONT_EONT
 253
 254 checkOptree ( name      => 'local $a=undef',
 255               prog      => 'local $a=undef',
 256               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 257               note      => 'locals are rare, probly not worth doing',
 258               bcopts    => '-basic',
 259               @open_todo,
 260               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 261 6  <@> leave[1 ref] vKP/REFC ->(end)
 262 1     <0> enter ->2
 263 2     <;> nextstate(main 1 -e:1) v:{ ->3
 264 5     <2> sassign vKS/2 ->6
 265 3        <0> undef s ->4
 266 -        <1> ex-rv2sv sKRM*/129 ->5
 267 4           <#> gvsv[*a] s/LVINTRO ->5
 268 EOT_EOT
 269 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 270 # 1     <0> enter ->2
 271 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 272 # 5     <2> sassign vKS/2 ->6
 273 # 3        <0> undef s ->4
 274 # -        <1> ex-rv2sv sKRM*/129 ->5
 275 # 4           <$> gvsv(*a) s/LVINTRO ->5
 276 EONT_EONT
 277
 278 checkOptree ( name      => 'sub {my $a=()}',
 279               code      => sub {my $a=()},
 280               bcopts    => '-exec',
 281               @open_todo,
 282               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 283 1  <;> nextstate(main -439 optree.t:105) v
 284 2  <0> stub sP
 285 3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
 286 4  <2> sassign sKS/2
 287 5  <1> leavesub[1 ref] K/REFC,1
 288 EOT_EOT
 289 # 1  <;> nextstate(main 438 optree_varinit.t:247) v
 290 # 2  <0> stub sP
 291 # 3  <0> padsv[$a:438,439] sRM*/LVINTRO
 292 # 4  <2> sassign sKS/2
 293 # 5  <1> leavesub[1 ref] K/REFC,1
 294 EONT_EONT
 295
 296 checkOptree ( name      => 'sub {our $a=()}',
 297               code      => sub {our $a=()},
 298               #todo     => 'probly not worth doing',
 299               bcopts    => '-exec',
 300               @open_todo,
 301               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 302 1  <;> nextstate(main 31 optree.t:177) v:{
 303 2  <0> stub sP
 304 3  <#> gvsv[*a] s/OURINTR
 305 4  <2> sassign sKS/2
 306 5  <1> leavesub[1 ref] K/REFC,1
 307 EOT_EOT
 308 # 1  <;> nextstate(main 440 optree_varinit.t:262) v:{
 309 # 2  <0> stub sP
 310 # 3  <$> gvsv(*a) s/OURINTR
 311 # 4  <2> sassign sKS/2
 312 # 5  <1> leavesub[1 ref] K/REFC,1
 313 EONT_EONT
 314
 315 checkOptree ( name      => 'sub {local $a=()}',
 316               code      => sub {local $a=()},
 317               #todo     => 'probly not worth doing',
 318               bcopts    => '-exec',
 319               @open_todo,
 320               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 321 1  <;> nextstate(main 33 optree.t:190) v:{
 322 2  <0> stub sP
 323 3  <#> gvsv[*a] s/LVINTRO
 324 4  <2> sassign sKS/2
 325 5  <1> leavesub[1 ref] K/REFC,1
 326 EOT_EOT
 327 # 1  <;> nextstate(main 63 optree.t:225) v:{
 328 # 2  <0> stub sP
 329 # 3  <$> gvsv(*a) s/LVINTRO
 330 # 4  <2> sassign sKS/2
 331 # 5  <1> leavesub[1 ref] K/REFC,1
 332 EONT_EONT
 333
 334 checkOptree ( name      => 'my $a=()',
 335               prog      => 'my $a=()',
 336               bcopts    => '-exec',
 337               @open_todo,
 338               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 339 1  <0> enter
 340 2  <;> nextstate(main 1 -e:1) v:{
 341 3  <0> stub sP
 342 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 343 5  <2> sassign vKS/2
 344 6  <@> leave[1 ref] vKP/REFC
 345 EOT_EOT
 346 # 1  <0> enter
 347 # 2  <;> nextstate(main 1 -e:1) v:{
 348 # 3  <0> stub sP
 349 # 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 350 # 5  <2> sassign vKS/2
 351 # 6  <@> leave[1 ref] vKP/REFC
 352 EONT_EONT
 353
 354 checkOptree ( name      => 'our $a=()',
 355               prog      => 'our $a=()',
 356               #todo     => 'probly not worth doing',
 357               bcopts    => '-exec',
 358               @open_todo,
 359               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 360 1  <0> enter
 361 2  <;> nextstate(main 1 -e:1) v:{
 362 3  <0> stub sP
 363 4  <#> gvsv[*a] s/OURINTR
 364 5  <2> sassign vKS/2
 365 6  <@> leave[1 ref] vKP/REFC
 366 EOT_EOT
 367 # 1  <0> enter
 368 # 2  <;> nextstate(main 1 -e:1) v:{
 369 # 3  <0> stub sP
 370 # 4  <$> gvsv(*a) s/OURINTR
 371 # 5  <2> sassign vKS/2
 372 # 6  <@> leave[1 ref] vKP/REFC
 373 EONT_EONT
 374
 375 checkOptree ( name      => 'local $a=()',
 376               prog      => 'local $a=()',
 377               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 378               #todo     => 'probly not worth doing',
 379               bcopts    => '-exec',
 380               @open_todo,
 381               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 382 1  <0> enter
 383 2  <;> nextstate(main 1 -e:1) v:{
 384 3  <0> stub sP
 385 4  <#> gvsv[*a] s/LVINTRO
 386 5  <2> sassign vKS/2
 387 6  <@> leave[1 ref] vKP/REFC
 388 EOT_EOT
 389 # 1  <0> enter
 390 # 2  <;> nextstate(main 1 -e:1) v:{
 391 # 3  <0> stub sP
 392 # 4  <$> gvsv(*a) s/LVINTRO
 393 # 5  <2> sassign vKS/2
 394 # 6  <@> leave[1 ref] vKP/REFC
 395 EONT_EONT
 396
 397 checkOptree ( name      => 'my ($a,$b)=()',
 398               prog      => 'my ($a,$b)=()',
 399               #todo     => 'probly not worth doing',
 400               bcopts    => '-exec',
 401               @open_todo,
 402               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 403 # 1  <0> enter
 404 # 2  <;> nextstate(main 1 -e:1) v:{
 405 # 3  <0> pushmark s
 406 # 4  <0> pushmark sRM*/128
 407 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 408 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 409 # 7  <2> aassign[t3] vKS
 410 # 8  <@> leave[1 ref] vKP/REFC
 411 EOT_EOT
 412 # 1  <0> enter
 413 # 2  <;> nextstate(main 1 -e:1) v:{
 414 # 3  <0> pushmark s
 415 # 4  <0> pushmark sRM*/128
 416 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 417 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 418 # 7  <2> aassign[t3] vKS
 419 # 8  <@> leave[1 ref] vKP/REFC
 420 EONT_EONT
 421
 422 } #skip
 423
 424 __END__
 425