erl_lint(3)

erl_lint(3erl)             Erlang Module Definition             erl_lint(3erl)

NAME
       erl_lint - The Erlang code linter.

DESCRIPTION
       This  module  is used to check Erlang code for illegal syntax and other
       bugs. It also warns against coding practices that are not recommended.

       The errors detected include:

         * Redefined and undefined functions

         * Unbound and unsafe variables

         * Illegal record use

       The warnings detected include:

         * Unused functions and imports

         * Unused variables

         * Variables imported into matches

         * Variables exported from if/case/receive

         * Variables shadowed in funs and list comprehensions

       Some of the warnings are optional, and can be turned on  by  specifying
       the appropriate option, described below.

       The  functions  in  this module are invoked automatically by the Erlang
       compiler. There is no reason to invoke these functions  separately  un-
       less you have written your own Erlang compiler.

DATA TYPES
       error_info() = {erl_anno:line(), module(), error_description()}

       error_description() = term()

EXPORTS
       format_error(ErrorDescriptor) -> io_lib:chars()

              Types:

                 ErrorDescriptor = error_description()

              Takes an ErrorDescriptor and returns a string that describes the
              error or warning. This function  is  usually  called  implicitly
              when processing an ErrorInfo structure (see section Error Infor-
              mation).

       is_guard_test(Expr) -> boolean()

              Types:

                 Expr = erl_parse:abstract_expr()

              Tests if Expr is a legal guard test. Expr is an Erlang term rep-
              resenting    the    abstract    form    for    the   expression.
              erl_parse:parse_exprs(Tokens) can be used to generate a list  of
              Expr.

       module(AbsForms) -> {ok, Warnings} | {error, Errors, Warnings}

       module(AbsForms, FileName) ->
                 {ok, Warnings} | {error, Errors, Warnings}

       module(AbsForms, FileName, CompileOptions) ->
                 {ok, Warnings} | {error, Errors, Warnings}

              Types:

                 AbsForms         =        [erl_parse:abstract_form()        |
                 erl_parse:form_info()]
                 FileName = atom() | string()
                 CompileOptions = [compile:option()]
                 Warnings = [{file:filename(), [ErrorInfo]}]
                 Errors = [{FileName2 :: file:filename(), [ErrorInfo]}]
                 ErrorInfo = error_info()

              Checks all the forms in a module for errors. It returns:

                {ok,Warnings}:
                  There are no errors in the module.

                {error,Errors,Warnings}:
                  There are errors in the module.

              As this module is of interest only to  the  maintainers  of  the
              compiler,  and  to avoid the same description in two places, the
              elements of Options that control the warnings are only described
              in the compile(3erl) module.

              AbsForms  of  a  module,  which  comes  from a file that is read
              through epp, the Erlang preprocessor, can come from many  files.
              This  means that any references to errors must include the file-
              name,  see   the   epp(3erl)   module   or   parser   (see   the
              erl_parse(3erl)  module).  The returned errors and warnings have
              the following format:

              [{FileName2,[ErrorInfo]}]

              The errors and warnings are listed in the order  in  which  they
              are  encountered  in  the  forms.  The  errors from one file can
              therefore be split into different entries in the list of errors.

ERROR INFORMATION
       ErrorInfo is the standard ErrorInfo structure that is returned from all
       I/O modules. The format is as follows:

       {ErrorLine, Module, ErrorDescriptor}

       A string describing the error is obtained with the following call:

       Module:format_error(ErrorDescriptor)

SEE ALSO
       epp(3erl), erl_parse(3erl)

Ericsson AB                       stdlib 3.13                   erl_lint(3erl)