Let me add that source() is intended to be a class method (essentially an inheritable constant), and that the goal would be to create new class methods storing additional data derived from source() at the points in the class hierarchy where source() is defined or re-defined.

It is true that the system could be redesigned to handle this better. But I was primarily interested in whether the information where Perl ultimately finds a method is accessible.

what you're saying is if he's developing a low level or mid level tool, or something for developers, he should forget about it. hey look two of us can ignore a post and offer incorrect conjecture

#!/usr/bin/perl

use strict;
use warnings;
use Method::Specialize;
use Moose::Util;

my $cached = 0;
my $gen = 0;

{
    package RoleA;
    use Moose::Role;

    sub sourceA { print "Testing sourceA\n";}
    sub readsource { print "RoleA contains sourceA\n";}

    package RoleB;
    use Moose::Role;

    sub sourceB { }

    package RoleC;
    use Moose::Role;

    sub sourceC { }

    package Class;
    use Moose;

    with qw(RoleA);

    ::specializing_method source => sub {
        my $class = shift;

        my $meta = Class::MOP::Class->initialize($class);

        my %roles = map { $_->name = undef }
            map { Class::MOP::Class->initialize($_)->calculate_all_rol
+es }
                $meta->linearized_isa;

        ++$gen;

        return sub {
            my ( $class, $role ) = @_;
            ++$cached;
            exists $roles{$role};

        }
    };

    package Method;
    use Moose;

    extends qw(Class);
}
Method->readsource;
[download]

#!perl -l

package A;

sub foo { "A::foo" }
sub bar { 'A::bar' }

package C;
@ISA = 'A';

sub bar { 'bar' }

package main;
use B 'svref_2object';

$x = bless {}, 'C';
for (qw(foo bar)) {
    print "$_ is from ", svref_2object(UNIVERSAL::can($x, $_))->GV->ST
+ASH->NAME;
}
[download]

The stash name is the name of the current package in which perl compiled the method. It can be wrong in cases where a method in a class comes from elsewhere, such as a role or a mixin.

No, this is all compiled in main:

#!perl -l

$y='main';$A::y='A';$C::y='C';

sub A::foo { $y }
sub A::bar { $y }

@C::ISA = 'A';

sub C::bar { $y }

use B 'svref_2object';

$x = bless {}, 'C';
for (qw(foo bar)) {
    print "$_ -> ", $x->$_, " from ", svref_2object(UNIVERSAL::can($x,
+ $_))->GV->STASH->NAME;
}
[download]

I guess the role and mixin stuff on CPAN must do something else if it breaks this.

use Class::ISA;
sub method_class {
    my ($self, $method_name) = @_;
    my $coderef;
    my $class;
    foreach (Class::ISA::self_and_super_path(ref($self)||$self)) {
        my $coderef_cur = $_->can($method_name);
        last unless defined $coderef_cur;
        last if defined $coderef and $coderef ne $coderef_cur;
        $coderef = $coderef_cur;
        $class = $_;
    }
    return $class;
}
[download]

Shouldn't you use base instead of ISA, well at least according to Perl::Critic?
Don't use '#ff0000':
use Acme::AutoColor;
my $redcolor = RED();