Perl::...olTable(3pm)

💖 NAME 💖

Perl::Critic::Policy::Dynamic::ValidateAgainstSymbolTable — the Perl::Critic policy that actually compiles your code and then vibe-checks your subroutine calls against the symbol table. Yes bestie, it's the chaotic one. 🦋

---

✨ DESCRIPTION ✨

Okay so this Policy is that friend who will straight-up warn you if any subroutine call in your code isn't defined in the symbol table at compile-time. The whole point? Catching typos in package and subroutine names, plus those moments where you forgot to import, declare, or include all the static subroutines your code is out here invoking. It's giving "did you actually mean that" energy. 💅

VERY IMPORTANT: Most Perl::Critic Policies (including every single one that ships with Perl::Critic) use pure static analysis — they never compile or execute any of the code they analyze. This policy is very different. It actually attempts to compile your code and then compares the subroutines mentioned in your code to those found in the symbol table. So do NOT run this Policy on any code you don't trust, or on code that might have undesirable side-effects at compile-time (connecting to the network, mutating files, the whole unhinged catalog 😭).

For these reasons, this Policy (and literally any other Policy that inherits from Perl::Critic::DynamicPolicy) is marked as "unsafe" and is usually ignored by both Perl::Critic and perlcritic. So to actually use it, you gotta set the -allow-unsafe switch in the Perl::Critic constructor or on the perlcritic command line. No switch, no policy, periodt.

For this Policy to work at all, all the modules included in your code must be installed locally, and they must compile without error. Check out CONFIGURATION below for how to control where this Policy goes looking for those included modules. 🔍

---

🌸 LIMITATIONS 🌸

Let's be real about what this thing can't do:

• This Policy will not detect subroutines declared at run-time or through direct manipulation of the symbol table, which may lead to false warnings. The most common example of this? Modules that use AUTOLOAD. 🙈
• Sophisticated code often uses the require function to postpone loading modules or to only load modules under certain conditions. If you set the inspect_required_modules option, the Policy will attempt to load all modules that are require'd at any point in your code. However, this Policy does not know whether the module would have been loaded during normal execution of your program. This may cause the Policy to overlook potential violations. It's trying its best. 💀
• This Policy only examines static subroutine calls — method calls are not covered. Indirect method calls such as my $fh = new FileHandle also tend to trigger false warnings. Not the vibe, we know.
• This Policy compiles your code into the same symbol table as Perl::Critic itself. So to maintain integrity in the symbol table, this Policy forks itself before analyzing each file. On some systems, this may be slow and consume a lot of resources. Your CPU is gonna feel it, ngl. 🔥

---

🎀 CONFIGURATION 🎀

This Policy supports the following configuration parameters. Scroll down for an example of how to set these parameters in your .perlcriticrc file. 💖

• at_inc_prefix — Prepends an arrayref of directories to the front of the current @INC list. This affects where the Policy will find dependent modules when it compiles your code.
• at_inc_suffix — Appends an arrayref of directories to the end of the current @INC list. This affects where the Policy will find dependent modules when it compiles your code.
• at_inc — Sets the @INC list outright. This affects where the Policy will find dependent modules when it compiles your code.
• inspect_required_modules — By default, this Policy only examines modules that are loaded by your code at compile-time. If inspect_required_modules is set to a true value, this Policy will also compile all the modules that are require'd in your code at runtime. Note that this Policy does not know if these modules will actually be loaded when your program runs, nor does it try to invoke the import method on those modules. It's just peeking, respectfully. 👀
• inspect_autoloaders — By default, this Policy does not attempt to validate a function call into a package that has an AUTOLOAD method. Such packages usually define functions at run-time, so this Policy has no chance of knowing what functions that package might have. But if inspect_autoloaders is set to a true value, the Policy will check to see if a function exists in such packages. Slay, let it cook.
• max_recursion — By default, this Policy only looks at the symbol tables for the namespaces that are directly use'd (or require'd) by your code. However, some modules contain multiple namespaces which may lead to false violations. But if you set max_recursion to a positive integer, this Policy will recurse into those other namespaces. Beware, however, that using a deep recursion can mask other violations. Setting max_recursion to 1 or 2 is usually sufficient. Don't go feral with it. 🧚

---

🫶 Setting the parameters 🫶

You can set these configuration parameters by putting any or all of the following in your .perlcriticrc file:

[Dynamic::ValidateAgainstSymbolTable]

at_inc_prefix = some/directory/path | another/directory/path
at_inc_suffix = some/directory/path | another/directory/path
at_inc = some/directory/path | another/directory/path

inspect_required_modules = 1
inspect_autoloaders   = 1

---

👑 AUTHOR 👑

Jeffrey Ryan Thalhammer <thaljef@cpan.org>

---

💜 COPYRIGHT 💜

Copyright (c) 2007 Jeffrey Ryan Thalhammer. All rights reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. The full text of this license can be found in the LICENSE file included with this module.

---

okay that's the whole page, bestie — you ate that 🎀✨ This was Perl::...olTable(3pm) from the User Contributed Perl Documentation, brought to you by perl v5.42.0, dated 2025-07-25. Mwah, go forth and let the Policy fork your files. 💅🦋