use warnings; use strict; use 5.008;
sub monk($) {}
some_code_that_defines_a_sub_mink();
sub go() { mink(123); }
[download]

Long answer: perl doesn't know at compile time whether the typeglob CODE slot it allocates at compile time will be actually filled with code at run time.

#!/usr/bin/perl
#
use warnings; use strict; use 5.008;
sub monk($) {}
sub go() { mink(123); }
BEGIN { print "$_\n" for grep { /^m/ } sort keys %main:: }
go();
__END__
main::
mink
monk
Undefined subroutine &main::mink called at sub.pl line 5.
[download]

Mentioning a subroutine somewhere in the code has (as far as typeglob allocation goes) a similar effect as subroutine forward declarations:

#!/usr/bin/perl
#
use warnings; use strict; use 5.008;
sub mink;      # sub mink still undefined, but typeglob allocated.
sub monk($) {}
sub go() { mink(123); }
BEGIN { print "$_\n" for grep { /^m/ } sort keys %main:: }
go();
__END__
main::
mink
monk
Undefined subroutine &main::mink called at sub.pl line 6.
[download]

AFAIK there's no pragma which enforces allocating the code reference *) in the CODE slot along with typeglob allocation.

*) Actually it is not just the code reference (which is what you get when you look into the CODE slot) but something deeper in perl's data structures. That is why

use strict;
$SIG{CHLD} = \&mywait; # value in the %SIG hash is an empty code ref
[download]

compiles without problem, even if the sub mywait { } never gets defined, and the coderef therefor is never populated with code proper.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

package foo;
use warnings;
use strict;
sub monk {
  return 42;
}
sub go {
  return mink(123);
}
1;
__END__
[download]

use strict;
use warnings;

use Test::More tests => 3;
use lib qw (.);

BEGIN {
  use_ok('foo');
}

# ------ monk ------
cmp_ok(foo::monk(), q{==}, 42, q{Expect monk to return 42});

# ------ go ------
cmp_ok(foo::go(), q{==}, 42, q{Expect go to return 42});
__END__
[download]

$ prove foo.t
foo....ok 1/3Undefined subroutine &foo::mink called at foo.pm line 8.
# Looks like you planned 3 tests but only ran 2.
# Looks like your test died just after 2.
foo....dubious
        Test returned status 255 (wstat 65280, 0xff00)
DIED. FAILED test 3
        Failed 1/3 tests, 66.67% okay
Failed Test Stat Wstat Total Fail  List of Failed
----------------------------------------------------------------------
+---------
foo.t        255 65280     3    2  3
Failed 1/1 test scripts. 1/3 subtests failed.
Files=1, Tests=3,  1 wallclock secs ( 0.04 cusr +  0.00 csys =  0.04 C
+PU)
Failed 1/1 test programs. 1/3 subtests failed.
[download]

Andreas, thanks, but this is catching the problem at runtime. Ideally what I would like is a warning/error when referencing a sub which is not already defined. I'm sure this isn't possible in the general case, but perhaps it is possible for code similar to my simple example?
--Ben

The problem is, it may require running the script to determine if a function really isn't defined. You may have two scripts that declare functions into the same namespace, use AUTOLOAD, or generate functions within the script (possibly with input from an external source)

foreach my $function (<DATA>) {
    no strict refs;
    chomp $function;
    *$function = sub { print "$function : @_\n"; };
}

mink(12);
go('somewhere');
monk(8);

__DATA__
mink
go
[download]

Hi Ben,

Read Re: Perl 5's greatest limitation is...?.

I believe that compile-time warnings like the one you are looking for is very hard, if not impossible, to do in Perl.

--
Andreas

 
BEGIN {
use warnings;
use strict;
use 5.008;

go();

sub monk {}
sub go { mink(123); }
};

print "After compilation, this message appears\n";
__END__
Outputs:
Undefined subroutine &main::mink called at try.pl line 9.
BEGIN failed--compilation aborted at try.pl line 11.
[download]

Cheater!
<Reveal this spoiler or all in this thread>

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

And the print "After compilation, this message appears\n"; that never gets executed .... that must be post-runtime code :-)

You're right, of course - the <flippancy> tags could just as well (or better) be replaced with <cheat> tags.

Cheers,
Rob

use warnings; use strict;
sub monk {}
sub go { mink 123; }
[download]

Done.

It also wouldn't be hard to write a module to scan the symbol table for references to undefined subroutines after the main script finished compiling and right before it starts running. I believe diotalevi(?) already wrote a module to report references to undefined subroutines.

I didn't write B::Lint. It comes with your perl.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

I guess diotalevi's solution is what I was looking for:

> perl -MO=Lint -c mink.pl
Nonexistant subroutine 'mink' called at mink.pl line 4
mink.pl syntax OK
[download]

It's a pity that it doesn't work on Windows to add '-MO=Lint' in the shebang line.

Thanks everyone for your help and/or entertaining suggestions.