manpagez: man pages & more
man B::Lint(3)
Home | html | info | man
B::Lint(3pm)           Perl Programmers Reference Guide           B::Lint(3pm)


       B::Lint - Perl lint


       perl -MO=Lint[,OPTIONS]


       The B::Lint module is equivalent to an extended version of the -w
       option of perl. It is named after the program lint which carries out a
       similar process for C programs.


       Option words are separated by commas (not whitespace) and follow the
       usual conventions of compiler backend options. Following any options
       (indicated by a leading -) come lint check arguments. Each such
       argument (apart from the special all and none options) is a word
       representing one possible lint check (turning on that check) or is no-
       foo (turning off that check). Before processing the check arguments, a
       standard list of checks is turned on. Later options override earlier
       ones. Available options are:

               Produces a warning whenever the magic "<>" readline is used.
               Internally it uses perl's two-argument open which itself treats
               filenames with special characters specially. This could allow
               interestingly named files to have unexpected effects when

                 % touch 'rm *|'
                 % perl -pe 1

               The above creates a file named "rm *|". When perl opens it with
               "<>" it actually executes the shell program "rm *". This makes
               "<>" dangerous to use carelessly.

       context Produces a warning whenever an array is used in an implicit
               scalar context. For example, both of the lines

                   $foo = length(@bar);
                   $foo = @bar;

               will elicit a warning. Using an explicit scalar() silences the
               warning. For example,

                   $foo = scalar(@bar);

       implicit-read and implicit-write
               These options produce a warning whenever an operation
               implicitly reads or (respectively) writes to one of Perl's
               special variables.  For example, implicit-read will warn about


               and implicit-write will warn about these:


               Both implicit-read and implicit-write warn about this:

                   for (@a) { ... }

               This option warns whenever a bareword is implicitly quoted, but
               is also the name of a subroutine in the current package.
               Typical mistakes that it will trap are:

                   use constant foo => 'bar';
                   @a = ( foo => 1 );
                   $b{foo} = 2;

               Neither of these will do what a naive user would expect.

               This option warns whenever $_ is used either explicitly
               anywhere or as the implicit argument of a print statement.

               This option warns on each use of any variable, subroutine or
               method name that lives in a non-current package but begins with
               an underscore ("_"). Warnings aren't issued for the special
               case of the single character name "_" by itself (e.g. $_ and

               This option warns whenever an undefined subroutine is invoked.
               This option will only catch explicitly invoked subroutines such
               as "foo()" and not indirect invocations such as "&$subref()" or
               "$obj->meth()". Note that some programs or modules delay
               definition of subs until runtime by means of the AUTOLOAD

               This option warns whenever one of the regexp variables "$`", $&
               or "$'" is used. Any occurrence of any of these variables in
               your program can slow your whole program down. See perlre for

       all     Turn all warnings on.

       none    Turn all warnings off.


       -u Package
               Normally, Lint only checks the main code of the program
               together with all subs defined in package main. The -u option
               lets you include other package names whose subs are then
               checked by Lint.


       Lint can be extended by with plugins. Lint uses Module::Pluggable to
       find available plugins. Plugins are expected but not required to inform
       Lint of which checks they are adding.

       The "B::Lint->register_plugin( MyPlugin => \@new_checks )" method adds
       the list of @new_checks to the list of valid checks. If your module
       wasn't loaded by Module::Pluggable then your class name is added to the
       list of plugins.

       You must create a "match( \%checks )" method in your plugin class or
       one of its parents. It will be called on every op as a regular method
       call with a hash ref of checks as its parameter.

       The class methods "B::Lint->file" and "B::Lint->line" contain the
       current filename and line number.

         package Sample;
         use B::Lint;
         B::Lint->register_plugin( Sample => [ 'good_taste' ] );

         sub match {
             my ( $op, $checks_href ) = shift @_;
             if ( $checks_href->{good_taste} ) {


       while(<FH>) stomps $_
       strict oo
       unchecked system calls
       more tests, validate against older perls


       This is only a very preliminary version.


       Malcolm Beattie,

perl v5.10.0                      2007-12-18                      B::Lint(3pm)

Mac OS X 10.6 - Generated Thu Sep 17 20:10:43 CDT 2009
© 2000-2018
Individual documents may contain additional copyright information.