But a global $foo isn't getting set -- otherwise "-w/use strict" would complain.

I honestly have no idea what in the semantic rules of Perl describes the behavior you are seeing. Why this compiles, and does what it does without complianing is beyond me. I would expect it to complain the same way this does...

#!/usr/bin/perl -w
use strict;
sub mycode {
  my $var = $_[0];
  my $foo = "blah" if $var; 
  print "foo is $foo\n" if $foo;
  $bar ||= "BAR";
}
mycode("test");
mycode();
mycode();
mycode();
[download]

It looks like you are absolutely right. The output of perl -MO=Deparse,-p a.pl follows (after removing Data::Dumper):

sub mycode {
    (my $var = $_[0]);
    (defined($var) ? print("mycode() called with $var\n") :
print("mycode() called with no operands.\n"));
    ($var and (my $foo = 'blah'));
#^^^^^^^^^^^^^^^ Look here
    ($foo and print("foo is $foo\n"));
    ($foo ||= 'FOO');
}
mycode('test');
mycode();
mycode();
mycode();
a.pl syntax OK
[download]

my $foo = 'blah' is optimized away.

In order to make it behave as expected, my $foo; needs to be its own statement, with no conditional.

Update: Removed bit about strict, see the follow up

my $foo = 'blah' is optimized away. It looks like $foo is still in the symbol table for mycode, so strict doesn't complain on any subsequent calls.

Hmm. I don't agree and/or don't completely understand what you're saying. (1) What do you mean by "optimized away"? (2) if $foo is in a symbol table, can you provide example code to print foo outside of the sub mycode{} block?

On a side note, does anyone know of links/books/perldoc that I can look at which document this "feature"?

---
"A Jedi uses the Force for knowledge and defense, never for attack."

I'm not sure that quite works. In theory, on the first call, my $foo = "blah" should be run, then go out of scope at the end of the function call. So, if the declaration/assignment is not run on the second call, shouldn't $foo ||= "FOO" give us an error?

I vaguely recall reading something about the duality of run-/compilation timeness of my causing this. Unless I'm off by several orbits, the cause was that the scope is determined at compilation time, but the actual scalar is allocated at runtime, and is the same thing as causes $bar to persist in things like

sub foo {
    my $bar = 0;
    sub baz {
        print $bar++;
    }
}
[download]

(You know the drill - Variable "$bar" will not stay shared.)

Makeshifts last the longest.

The reason we cant give an error is because my $foo = "blah" only gets executed if $var is true. However, we dont actually know if $var is true or not until runtime.

So when you call mycode() with no arguments then my $foo = 'blah' is not executed at all. Instead, simply $foo = 'FOO' gets executed, setting $main::foo (you can verify this by printing out $main::foo after you call mycode() with no arguments).

use strict is only supposed to catch compile-time errors (according to its documentation). It should not blow up at runtime.

To do what you expect here you could do something like:

    my $foo = defined $var ? 'blah' : 'FOO';

or even:

    my $foo;
    if ($var) {
        $foo = 'blah';
    }
    else {
        $foo = 'FOO';
    }

my $foo = 'blah' is not executed at all. Instead, simply $foo = 'FOO' gets executed, setting $main::foo (you can verify this by printing out $main::foo after you call mycode() with no arguments).

Wrong. Actually, the fact that $foo is scoped lexically must be known at compile time - think about it, how else would strict work? After the compiler sees a my, it generates ops referring to lexicals rather than globals for the variables. However, allocation of these lexicals happens at runtime. By adding an if, you prevent the allocation at runtime, but you do not prevent the lexical scoping that happens at compile time.

The effect is that subsequent invocations of the routine refer to a lexically scoped scalar that was allocated in a previous invocation - the same way as closures do.

Makeshifts last the longest.

I concur, except for this part:

So when you call mycode() with no arguments then my $foo = 'blah' is not executed at all. Instead, simply $foo = 'FOO' gets executed, setting $main::foo (you can verify this by printing out $main::foo after you call mycode() with no arguments).

I had a line in my original code that dumped the symbol table:

print Dumper(\%main::);

But threw this out because I am never able to see $foo in the symbol table for the main package. Are you?

---
"A Jedi uses the Force for knowledge and defense, never for attack."