Two problems.

• First, as the warning indicates, the main::open in

  *{main::open} = sub { print "Ho\n"; };
  [download]

  is interpreted as a call to open. (Upd: Not sure how it's being interpreted anymore, but it's definitely not working as expected. ) You want

  my $glob_ref = do { no strict 'refs'; \*{'main::open'} };
  *$glob_ref = sub { print "Ho\n"; };
  [download]

• Second, you delude yourself by putting the use subs at the bottom.

  BEGIN {
          # Deleting and remaking the sub fails! ;(
          delete $main::{open};
          *{main::open} = sub { print "Ho\n"; };
          use subs 'open';
  }
  [download]

  means

  BEGIN {
          # Deleting and remaking the sub fails! ;(
          delete $main::{open};
          *{main::open} = sub { print "Ho\n"; };
          BEGIN {
                  require subs;
                  import subs 'open';
          }
  }
  [download]

  which is compiled and executed as follows:

  1. "delete $main::{open};" is compiled.
  2. "*{main::open} = sub { print "Ho\n"; };" is compiled.
  3. "require subs;" is compiled.
  4. "import subs 'open';" is compiled.
  5. "require subs;" is executed. (The inner BEGIN is executed as soon as it's compiled.)
  6. "import subs 'open';" is executed.
  7. "delete $main::{open};" is executed. (The outer BEGIN is executed as soon as it's compiled.)
  8. "*{main::open} = sub { print "Ho\n"; };" is executed.

  "import subs 'open';" should not be executed before "delete $main::{open};".

Fixed:

use strict;
use warnings;

use subs qw( );

open(my $fh, '<', $0);  # Calls CORE::open

BEGIN {
        my $glob = do { no strict 'refs'; \*{'main::open'} };
        *$glob = sub { print "Hi\n"; };
        import subs 'open';
}

open(my $fh2, '<', $0); # Prints Hi

BEGIN {
        delete $main::{open};

        my $glob = do { no strict 'refs'; \*{'main::open'} };
        *$glob = sub { print "Ho\n"; };
        import subs 'open';
}

open(my $fh4, '<', $0);  # Prints Ho

BEGIN {
        delete $main::{open};
}

open(my $fh5, '<', $0);  # Calls CORE::open
[download]

By the way, if that BEGIN block will end up being use statement, use subs is not needed. For example,

override.pm:

use strict;
use warnings;

package override;

sub import {
   my ($class, $sub_name, $sub) = @_;
   my $pkg_name = caller();

   my $pkg_sym = _pkg_symtab($pkg_name);
   delete $pkg_sym->{$sub_name};

   if ($sub) {
      no strict 'refs';
      *{"${pkg_name}::$sub_name"} = $sub;
   }
}

sub _pkg_symtab {
   my ($pkg) = @_;
   my $p = \%::;
   $p = $p->{"${_}::"} for split /::/, $pkg;
   return $p;
}

1;
[download]

test.pl:

use strict;
use warnings;

open(my $fh, '<', $0);  # Calls CORE::open

use override open => sub { print "Hi\n"; };
open(my $fh2, '<', $0); # Prints Hi

use override open => sub { print "Ho\n"; };
open(my $fh4, '<', $0);  # Prints Ho

use override open => undef;
open(my $fh5, '<', $0);  # Calls CORE::open
[download]

Output:

>perl test.pl
Hi
Ho
[download]

From there, I guess the idea is to make overrideautodie a lexical pragma. Shouldn't be too hard.

ikegami, I cannot begin to express just how happy you've made me. Having simple, elegant, and understandable code that solves a problem that I've been beating my head against for days is stunningly good.

You've been added with an appropriate attribution to the AUTHORS file, and you can expect a future release of autodie to be named in your honour. ;)

Really, you rock. Thank-you so much for taking the time to show me a solution, it's exactly what I've been trying (and failing) to do.

Yours most humbly,

Paul Fenwick
Perl Training Australia