ianyappy:

One thing you have to understand about the statement  sub name { ... } is that it always executes at compile time if it is not in a string eval (i.e., is in a block  eval or is a nested subroutine definition in another subroutine). So your impression that "AUTOLOAD isn't even being called" is correct. See example below.

>perl -wMstrict -le
"{ package Foo;
   use warnings;  use strict;
   our $AUTOLOAD;
   sub AUTOLOAD {
     eval { sub foo { return 'FOO'; } };
     sub bar { return 'BAR'; }
     print qq{AUTOLOADing '$AUTOLOAD'};
     no strict 'refs';
     *$AUTOLOAD = sub { return uc $AUTOLOAD };
     goto &$AUTOLOAD;
     }
   }
 ;;
 print 'foo? ', exists &Foo::foo;  print Foo->foo;
 print 'bar? ', exists &Foo::bar;  print Foo->bar;
 print 'baz? ', exists &Foo::baz;  print Foo->baz;
 print 'baz? ', exists &Foo::baz;  print Foo->baz;
"
foo? 1
FOO
bar? 1
BAR
baz?
AUTOLOADing 'Foo::baz'
FOO::BAZ
baz? 1
FOO::BAZ
[download]

In this example,  Foo::foo and  Foo::bar already exist at runtime, so  AUTOLOAD is never called for them. The first time  Foo::baz is called,  AUTOLOAD is called and defines the subroutine and also executes the just-defined subroutine. When  Foo::baz is called subsequently, it exists.

Update: To pound the point about nested subroutine definitions even further into the ground, remove the  sub bar { return 'BAR'; } statement from the  AUTOLOAD function in the example above and replace the  eval statement with
    eval { sub foo { sub bar { return 'BAR'; }  return 'FOO'; } };
or the even more pathological
    eval { sub foo { return 'FOO';  sub bar { return 'BAR'; } } };
The results of execution are the same.

Ooops, what I Really meant was i did (use strict;use warnings;use 5.010;use Carp;) :) Not used to the lingo.

Now I understand what you mean by eval strings, I didn't realize the significance (eval q{} vs eval{}) but I do now.

I tried calling the method dynamically without using references. It seems to work just as fine:

#!/usr/bin/perl

use strict;
use 5.010;
use warnings;
use Carp;
{ package Foo;
    our $AUTOLOAD;
    sub AUTOLOAD {
        eval { sub foo { sub bar { return 'BAR'; }  return 'FOO'; } };
+ 
        print qq{AUTOLOADing '$AUTOLOAD'};
        my $method = $AUTOLOAD;
        $method =~ s/.*:://;
        $method eq 'baz' ? eval q{sub baz{ return uc $AUTOLOAD }} :die
+ "Invalid method.";
        goto &$method;
    }
}
 print 'foo? ', exists &Foo::foo;  say Foo->foo;
 print 'bar? ', exists &Foo::bar;  say Foo->bar;
 print 'baz? ', exists &Foo::baz;  say Foo->baz;
 print 'baz? ', exists &Foo::baz;  say Foo->baz; 

######OUTPUT#####
foo? 1FOO
bar? 1BAR
baz? AUTOLOADing 'Foo::baz'FOO::BAZ  #AUTOLOADING prints once
baz? 1FOO::BAZ
[download]

String found where operator expected at 879141.pl line 6, near "say "G
+oing into AUTOLOAD""
        (Do you need to predeclare say?)
String found where operator expected at 879141.pl line 9, near "Carp::
+croak "Invalid method: $method.""
        (Do you need to predeclare Carp::croak?)
syntax error at 879141.pl line 6, near "say "Going into AUTOLOAD""
syntax error at 879141.pl line 9, near "Carp::croak "Invalid method: $
+method.""
BEGIN not safe after errors--compilation aborted at 879141.pl line 26.
[download]

The first error tells me that say needs to be imported, the second that Carp isn't loaded. If nothing was printed for you, then that package didn't have warnings enabled.

2: Your code looked like this: if (foo) { eval { sub bar {} } }. You were defining a sub inside the AUTOLOAD sub, and then executing that code by name, instead of assigning to another variable a coderef, like $code = sub { ... }; and then later calling it or using goto on it.

3: Notice that the "was called" statement is executed unconditionally, after it's determined that DESTROY wasn't called.

Actually I get the impression that AUTOLOAD isn't even being called.