Nonexistent::Module->import() gives no error

[jimav]

Nonexistent::Module->import() silently succeeds. Expecting an error like

Can't locate object method "import" via package "Nonexistent::Module" (perhaps you forgot to load "Nonexistent::Module"?)

The docs say import is an ordinary method and not builtin, but that doesn't seem to be entirely true. I think this is a bug (calling any method on a non-existent object or class should result in an error);

if it can not be fixed, then I suggest updating the perlfunc entry for 'import' to explain what is happening.

#!/usr/bin/perl
use strict; use warnings;
use Data::Dumper;

$Data::Dumper::Terse = 1;

print "BEFORE:", Dumper(\%Misspelled::);
print "AGAIN :", Dumper(\%Misspelled::);

Misspelled->import();            # NO error

print "AFTER :", Dumper(\%Misspelled::);

Misspelled->othermethod(); # error as expected

Output:

BEFORE:{}
AGAIN :{}
AFTER :{
  'import' => *Misspelled::import
}
Can't locate object method "othermethod" via package "Misspelled" at /tmp/test.pl line 14.

[Grinnz]

It is unfortunate, but this is because of:

1. there is no way to conclusively decide if a module has been "loaded", because any perl code can define contents of any package;
2. "use" calls import on whatever you load, so it must succeed even if no such method exists

This is also the source of silent (or not so silent) failures in a circular "use", where the import method is called on a package before its code has been fully loaded.

[haarg]

The behavior of import is described better in the docs for use. Changing this behavior won't be possible, but the docs under import could definitely be improved.

[xenu]

I think calling non-existent import with arguments is basically always a mistake. Maybe that case should warn? It would also help on case-insensitive file systems:

use LIST::UTIL 'any'; # quietly doesn't import anything

[jimav]

2. "use" calls import on whatever you load, so it must succeed even if no such method exists

Must it? Could something like
&{ $modulename."::import" }(...) if defined(&{ $modulename."::import" })work?

Edit: Oh never mind -- that won't find 'import' if inherited from another class. But could "use" reliably determine if 'import' is defined by checking for @ ISA (recursively)?

[demerphq]

On Mon, 14 Feb 2022 at 07:40, Jim Avera ***@***.***> wrote: 2. "use" calls import on whatever you load, so it must succeed even if no such method exists Must it? Could something like $modulename->import(...) if defined(${ $modulename."::import" })work?

That would break with inherited ISA. Eg: package Foo; require Exporter; @isa=qw(Exporter); And actually isnt that the problem at heart? All classes are inherently ISA UNIVERSAL iirc, and it has an import method. Maybe this would work tho: $modulename->import(...) if $modulename->can("import") != UNIVERSAL->can("import"); Yves

[jimav]

BTW, UNIVERSAL->can("import") returns undef in v5.30.0

[demerphq]

On Mon, 14 Feb 2022 at 08:15, Jim Avera ***@***.***> wrote: BTW, UNIVERSAL->can("import") returns undef in v5.30.0

So it does. Ok, I guess I'm confused. Im digging to educate myself better tho. Yves

[demerphq]

On Mon, 14 Feb 2022 at 08:21, demerphq ***@***.***> wrote: On Mon, 14 Feb 2022 at 08:15, Jim Avera ***@***.***> wrote: > BTW, UNIVERSAL->can("import") returns undef in v5.30.0 > So it does. Ok, I guess I'm confused. Im digging to educate myself better tho.

For the record it is in gv.c line 1152. /* This is the special case that exempts Foo->import and Foo->unimport from being an error even if there's no import/unimport subroutine */ if (strEQ(name,"import") || strEQ(name,"unimport")) { gv = (GV*)sv_2mortal((SV*)newCONSTSUB_flags(NULL, NULL, 0, 0, NULL)); Interestingly if code uses autouse then this special case is broken because it contains the following code: $import == \&UNIVERSAL::import and evaluating \&UNIVERSAL::import causes it to be created as a stub. ./perl -Ilib -le'print \&UNIVERSAL::import; print UNIVERSAL->can("import"); Foo->import()' CODE(0x5604a519c5a8) CODE(0x5604a519c5a8) Undefined subroutine &UNIVERSAL::import called at -e line 1. This logic has a long history. It was first introduced in Larry Walls a0d0e21 for Perl 5.0, where it was a0d0e21 (Larry Wall 1994-10-17 23:00:00 +0000 279) if (strEQ(name,"import") || strEQ(name,"unimport")) dc437b5 (Perl 5 Porters 1996-06-18 08:59:13 +0000 280) gv = (GV*)&sv_yes; This was then changed by Tim Bunce to not include unimport: 702887b (Tim Bunce 1996-11-18 18:06:15 +1200 375) if (strEQ(name,"import")) 3280af2 (Nick Ing-Simmons 1998-07-18 13:53:03 +0000 376) gv = (GV*)&PL_sv_yes; Then changed back to include unimport: 2f6e0fe (Mark-Jason Dominus 2000-03-24 15:24:34 +0000 1094) if (strEQ(name,"import") || strEQ(name,"unimport")) 159b6ef (Nicholas Clark 2008-10-31 08:55:20 +0000 1095) gv = MUTABLE_GV(&PL_sv_yes); It makes me wonder what would break if we simply defined UNIVERSAL->import() in universal.c and removed the special case. This would eliminate the issues that \&UNIVERSAL::import would not break anything. It does make me realize that the code we were discussing could be rewritten as it is to be: $module->import() if $module->can("import"); but I am not sure what that would solve. It wouldnt help the filename case error problem. However having a defined UNIVERSAL::import() *would* allow us to throw an error on the case that xenu mentioned: use LIST::UTIL 'any'; # quietly doesn't import anything as we could make UNIVERSAL::import() die if it was provided arguments. Yves

[demerphq]

On Mon, 14 Feb 2022 at 09:22, demerphq ***@***.***> wrote: However having a defined UNIVERSAL::import() *would* allow us to throw an error on the case that xenu mentioned: use LIST::UTIL 'any'; # quietly doesn't import anything as we could make UNIVERSAL::import() die if it was provided arguments.

See #19419

…

-- perl -Mre=debug -e "/just|another|perl|hacker/"