I think what's going on is that since @_ are aliases, this actually clears out the argument as well.

That would be the behaviour you'd get if local simply backed up the current value of a variable and restored it on scope exit.

As you discovered, that's not what local does. Instead, it creates a new variable, aliases the name to the new variable, and aliases the name back to the original variable on scope exit.

$ perl -e'
   use feature qw( say );
   say 0+\$x;
   { local $x; say 0+\$x; }
   say 0+\$x;
'
94031376424552
94031376229560
94031376424552
[download]

That means the fact that $_[0] is an alias for the localized variable shouldn't matter. And it normally doesn't.

$ perl -e'
   use feature qw( say );
   $x = 2;
   say 0+\$x;
   say $x;
   sub {
      local $x = 3;
      say 0+\$x;
      say $x;
      say $_[0];
   }->( $x );
   say 0+\$x;
   say $x;
'
94300947464040   Address of pre-local $x
2                Value of pre-local $x
94300947268840   Address of post-local $x
3                Value of post-local $x
2                Value of pre-local $x
94300947464040   $x is restored
2                Value of pre-local $x
[download]

But $! is magical. And more specifically, it's a proxy for a C variable. local copies the magic onto the new scalar it creates. So you end up with two variables (the $! passed as argument and the new $! created by local) which both use the same C variable for storage.

$ perl -e'
   use feature qw( say );
   $! = 2;
   say 0+\$!;
   say 0+$!;
   sub {
      local $! = 3;
      say 0+\$!;
      say 0+$!;
      say 0+$_[0];
   }->( $! );
   say 0+\$!;
   say 0+$!;
'
93839899443048   Address of pre-local $!
2                Value of pre-local $! (aka value of errno)
93839899247848   Address of post-local $!
3                Value of post-local $! (aka value of errno)
3                Value of pre-local $! (aka value of errno)
93839899443048   $! is restored
3                Value of pre-local $! (aka value of errno)
[download]

The net effect is that local $! doesn't really localize $! at all!

$? is similarly a proxy for a C variable. $@ isn't magical.

Accidentally submitted parent very early in its composition. (Mid sentence, even!) It has been heavily edited.

Grumble. I feared that it's something i couldn't blame Carp for. Oh well, i'll spend a couple of hours writing a Perl script that audits and fixes all my other Perl scripts and modules to make sure arguments to croak() are quoted properly.

Hmm, i could either modify an existing script (which probably has all the crud from the last 12 years) or ask ChatGPT to do it (and fix all the variable names and regular expressions). I could also write from scratch, but it's Monday and i'm not feeling THAT enthusiastic about fixing some error message handling...