Apply HINT_BLOCK_SCOPE to lexical variable declarations

[richardleach]

Apply HINT_BLOCK_SCOPE to lexical variable declarations

At present, any else {...} block is wrapped in an ENTER/LEAVE pair, even
if no new scope is warranted, which causes runtime inefficiency. For
example, this block doesn't need a scope but gets one anyway:

    } else {
        return 1;
    }

However, this behaviour means that an object like $kaboom will reliably
be destroyed when the else block is exited:

    } else {
        my $kaboom = TickTick->new;
    }

In contrast, if () {...} or elsif () {...} blocks default to not
having an ENTER/LEAVE pair, which is more efficient but arguably
incorrect, as $marvin in this code won't be destroyed when the if
block is exited:

    if ( $x ) {
        my $marvin = TickTick->new;
    }

Exactly when it is destroyed is dependent upon where the next scope
exit happens to be, and this could be some ways away from its block.

This behaviour is also very brittle, as shown in this case where the
no-op 0; statement causes - via a quirk of parsing - the if
block to be assigned an ENTER/LEAVE pair and so $marvin
will be destroyed when the block exits:

    if ( $x ) {
        0; my $marvin = TickTick->new;
    }

Whether a block gains a scope via ENTER/LEAVE pair or is just parented
by a SCOPE OP (that will be optimized away), is decided by
Perl_op_scope on the basis of the OPf_PARENS flag on a block's
LINESEQ OP. The parser always sets this flag for else blocks,
a variety of circumstances determines whether it is set otherwise.

This commit makes two changes:

• Removes the enforced use of the OPf_PARENS flag on else blocks.
  The same rules now apply to if, elsif, and else, hopefully making
  destruction behaviour more predictable.

• Changes the tokenizer such that occurrances of my, our, and state
  set the OPf_PARENS flag, and the containing block will be wrapped in
  an ENTER/LEAVE pair.

After this commit, neither of the if or else blocks in this example
will have an unnecessaryENTER/LEAVE pair:

    if ($x ) {
        return 0;    
    } else {
        return 1;
    }

And in this example, both objects will be destroyed when the relevant
block is exited:

    if ( $x ) {
        my $kaboom_true = TickTick->new;
    } else {
        my $kaboom_else = TickTick->new;
    }

Sadly, both blocks in this example will still have unnecessary scopes,
but fixing that is for a different PR:

    if ($x ) {
        0; return 0;    
    } else {
        0; return 1;
    }

There are two downsides to this commit:

1. It has the potential to change the destruction timing of objects created
   in an if block and assigned to a lexical declared within the block, if
   the block hasn't ended up with an ENTER/LEAVE pair. As noted above though.
   that behaviour is very brittle and already sensitive to even minor changes
   to the Perl code - and also to minor parser/optimization changes within the
   interpreter.

2. The old else behaviour meant that the first statement's NEXTSTATE OP
   stays in place and consequently any error messages arising from the first
   statement mention the correct (or closer) line number. The if/elsif
   behaviour is more likely to cause the NEXTSTATE OP to be optimized away,
   causing any error messages to contain the line number for where the if
   or elsif keyword keyword occurred, which could be many lines away.

Following this commit, first-line error messages will be just as bad
for an else block as they are for if/elsif blocks. However, that's
a separate issue and should not be a reason to avoid this commit.

---

• This set of changes requires a perldelta entry, and I need help writing it.