Instead, it appears to me by overwriting the namespace of Bar, you're overwriting everything in Bar::, including it's "identity". So class Bar is from now on, identified as class Foo.

Check out this similar, but even more reduced code:

{
    package Foo;
    sub foo { bless {}, "Bar" }
}

*Bar:: = \*Foo::;

use Data::Dumper;
print Dumper(Foo->foo);
[download]

$VAR1 = bless( {}, 'Foo' );
[download]

Drop the assignment of the stash, and it behaves as you and I expect.

I have no idea where the identity of the class is stored in the stash, but it must be somewhere — and you're overwriting it.

update: Replace the assignment of the stash with the less rigorous:

*Bar::foo = \*Foo::foo;
[download]

$VAR1 = bless( {}, 'Bar' );
[download]

print Dumper(Foo->foo);
print Dumper(Bar->foo);
[download]

This has got to be a bug and quite possibly the most bizarre behavior I've ever seen from perl.

duff

Frankly, this code does not do what I would expect it to to do.

Maybe its just getting late, but I am not sure I see why this is odd. You are not duplicating the contents of the TYPEGLOB, but just aliasing it. It's just a level of indirection, not a copy of the package. In fact, just changing one line to this:

%Bar:: = %Foo::;
[download]

Expected class: Bar
Actual class: Bar
Expected class: Bar
Actual class: Bar
[download]

Well, here's something related I don't quite get that might help. I modified your code somewhat:

use strict;

package Foo;
sub new  { print "Expected class: $_[0]"; bless {} => shift }
sub test { print "Actual class: ". ref shift }

  package main;
  *Bar:: = \*Foo::;

   my $x = Bar::new('Bar');
[download]

Now as I understand it, this ought to work because that last line is equivalent to my $x = Bar->new. But it doesn't. In fact it returns Undefined subroutine &Bar::new called at - line 9. So that makes me think that somehow doing a typeglob assignment on the symbol-table hash doesn't do what you'd expect it to. I haven't yet found any relevant docs though.

Errto

Your example and error message, makes me think that TYPEGLOB aliasing is basically a very shallow operation. Basically that it does not go any deeper than the top level GLOB. If you were to change the alias line to:

*Bar::new = \*Foo::new;
[download]

I get the following output:

Expected class: Bar
[download]

So that makes me think that somehow doing a typeglob assignment on the symbol-table hash doesn't do what you'd expect it to.

But you aren't doing it on the symbol table hash, you are doing it on the TYPEGLOB. Although oddly enough, if you do this:

%Bar:: = %Foo::;
my $x = Bar::new('Bar');
[download]

I get the same error you got with your example:

Undefined subroutine &Bar::new
[download]

Now that is something I wouldn't expect to happen.
-stvn

*Bar:: = \*Foo::;
[download]

*main{'Bar::'} = \*main{'Foo::'}
[download]

Hmm, this seems to be a trick with bless. At least that's all I can deduce from this snippet:

#!/usr/bin/perl -l
*Bar:: = \*Foo::;
print ref bless{}, "Bar";
__END__
Foo
[download]

Haven't seen anything about this in any of the docs but the behavior is consistent since at least 5.6.1.

Update: Even more curious...

#!/usr/bin/perl -l

sub Foo::j { print "F ",ref shift }
sub Bar::j { print "B ",ref shift }

$a = bless {}, "Bar";
*Bar:: = \*Foo::;
$b = bless {}, "Bar";

print "\$a is type ",ref $a;
print "\$b is type ",ref $b;

$a->j;

Bar::j($a);

*{"Bar::j"}{CODE}->($a);

$b->j;

__END__
$a is type Bar
$b is type Foo
B Bar
B Bar
F Bar
F Foo
[download]

I think there are some compile-time vs runtime considerations that must be made.

Update part 2: As far as I understand it, when you bless a reference, the blessed reference will get a pointer to the stash designated by the string you pass as the second parameter. The blessed reference never actually gets the string passed as the second parameter. What ref actually returns is the name on the stash to which the reference points. Thus since Bar points to Foo's stash, you will always get Foo when you bless with Bar.