That's a nice thing to know. Thank you! I've been bitten by errors reported in anonymous subs and this should make life easier.

#!/usr/local/bin/perl
use warnings;
use strict;
use Carp 'confess';

sub foo {
    sub {
        local *__ANON__ = 'local_subref';
        confess "Ovid";
    };
}

eval foo()->();
[download]

use Carp;
my $i = 0;

sub foo {
     sub {
         local *__ANON__ = "local_subref_" . $i++;
         carp "blokhead";
     };
}

foo()->() for 1 .. 3;

__OUTPUT__

$ perl -d:DProf test.pl 
blokhead at test.pl line 7
        main::local_subref_0() called at test.pl line 12
blokhead at test.pl line 7
        main::local_subref_1() called at test.pl line 12
blokhead at test.pl line 7
        main::local_subref_2() called at test.pl line 12
blokhead at test.pl line 7
        main::local_subref_3() called at test.pl line 12

$ dprofpp tmon.out
Total Elapsed Time = 0.079705 Seconds
  User+System Time = 0.049705 Seconds
Exclusive Times
%Time ExclSec CumulS #Calls sec/call Csec/c  Name
 ...
 0.00       -  0.020      3        - 0.0066  main::__ANON__
 ...
[download]

As maintainer of Class::MethodMaker, I have more than a passing interest in this technique: C::MM generates anonymous routines by the bucket-load, and as well as debugging, I'm particularly interested in profiling, too.

I'd been meaning to do something about this for a couple of years now, and this thread finally galvanized me into action. After two days of tinkering with it, and several false starts, I've finally come up with this XS incantation:

  void
  set_sub_name(SV *sub, char *pname, char *subname, char *stashname)
    CODE:
      CvGV((GV*)SvRV(sub)) = gv_fetchpv(stashname, TRUE, SVt_PV);
      GvSTASH(CvGV((GV*)SvRV(sub))) = gv_stashpv(pname, 1);
      GvNAME(CvGV((GV*)SvRV(sub))) = savepv(subname);
      GvNAMELEN(CvGV((GV*)SvRV(sub))) = strlen(subname);
[download]

The pname is the package name, the subname the subname, and stashname is the name of a stash to generate to attach the code to, to avoid overwriting the original stash (which is the package the code was compiled in), or the ANON entry in the pname stash. The above certainly appears to work, both with stack traces & the profiler, and doesn't break my code. I was concerned that generating a new stash for each subr might hurt the memory consumption, but empirical testing suggests that the effect is minimal-to-nil.

I'm no XS programmer, so I'd appreciate any constructive feedback anyone has.

I ran into similar issues when developing the Perl 6 metamodel stuff for Pugs, and more recently with Class::MOP. I use the Sub::Name module which has worked great for me, it is also written in XS, you might be able to get a few pointers out of the code (or better yet, just use it, why reinvent the wheel).

Of course I might also be 2 years to late with this comment too :)

-stvn

$ perl <<EOF
package Foo::Bar;
print sub { local *__ANON__ = "boo"; (caller(0))[3] }->();
EOF
Foo::Bar::boo

$ perl <<EOF
package Foo::Bar;
print sub { local *__ANON__ = "Foo::Zip::boo"; (caller(0))[3] }->();
EOF
Foo::Zip::boo
[download]