9.2 Warning options

-w

--inhibit-warnings

Disable all warning messages.

--inhibit-style-warnings

Disable all warning messages about programming style.

--halt-at-warn

This option causes the compiler to treat all warnings as if they were errors when generating target code. This means that if the compiler issues any warning, it will not generate target code — instead, it will return a non-zero exit status.

--halt-at-warn-make-int

--halt-at-warn-make-interface

This option causes the compiler to treat all warnings as if they were errors when generating an interface file (a ‘.int’, ‘.int0’, ‘.int2’ or ‘.int3’ file). This means that if the compiler issues any warnings at that time, it will not generate the interface file — instead, it will return a non-zero exit status.

--halt-at-warn-make-opt

This option causes the compiler to treat all warnings as if they were errors when generating an optimization file (a ‘.opt’ or ‘.trans_opt’ file). This means that if the compiler issues any warnings at that time, it will not generate the optimization file — instead, it will return a non-zero exit status.

--halt-at-syntax-error

This option causes the compiler to halt immediately after syntax checking and not do any semantic checking if it finds any syntax errors in the program.

--no-halt-at-invalid-interface

This option operates when the compiler is invoked with the –make–interface option to generate .int and .int2 files for one or more modules. In its default setting, ‘--halt-at-invalid-interface’, it causes the compiler to check the consistency of those parts of each of those modules that are intended to end up in the .int and .int2 files. If these checks find any problems, the compiler will stop without generating those files after printing an error message for each problem.

Users can prevent this behavior, and thus allow the generation of invalid interface files, by specifying ‘--no-halt-at-invalid-interface’.

--no-warn-accumulator-swaps

Do not warn about argument order rearrangement caused by ‘--introduce-accumulators’.

--no-warn-singleton-vars

--no-warn-singleton-variables

Do not warn about variables which only occur once, despite their names not starting with an underscore.

--no-warn-repeated-singleton-vars

--no-warn-repeated-singleton-variables

Do not warn about variables which occur more than once, despite their names starting with an underscore.

--no-warn-missing-det-decls

For predicates that are local to a module (those that are not exported), don’t issue a warning if the ‘pred’ or ‘mode’ declaration does not have a determinism annotation. Use this option if you want the compiler to perform automatic determinism inference for non-exported predicates.

--no-warn-det-decls-too-lax

Do not warn about determinism declarations which could have been stricter.

--no-warn-inferred-erroneous

Do not warn about procedures whose determinism is inferred erroneous but whose determinism declarations are laxer.

--no-warn-insts-without-matching-type

Do not warn about insts that are not consistent with any types in scope.

--warn-insts-with-functors-without-type

Warn about insts that do specify functors but do not specify what type they are for.

--warn-unused-imports

Warn about modules that are imported but not used.

--no-warn-nothing-exported

Do not warn about modules whose interface sections have no exported predicates, functions, insts, modes or types.

--warn-unused-args

Warn about predicate or function arguments which are not used.

--no-warn-unneeded-initial-statevars

Do not warn about state variables in clause heads that could be ordinary variables.

--no-warn-unneeded-initial-statevars-lambda

Do not warn about state variables in lambda expressions that could be ordinary variables.

--no-warn-unneeded-final-statevars

Do not warn about !:S state variables in clause heads whose value will always be the same as !.S.

--no-warn-unneeded-final-statevars-lambda

Do not warn about !:S state variables in lambda expressions whose value will always be the same as !.S.

--no-warn-interface-imports

Do not warn about modules imported in the interface which are not used in the interface.

--warn-interface-imports-in-parents

Warn about modules imported in the interface a parent module which are not used in the interface of that module.

--warn-missing-opt-files

Warn about ‘.opt’ files that cannot be opened.

--warn-missing-trans-opt-files

Warn about ‘.trans_opt’ files that cannot be opened.

--warn-inconsistent-pred-order

--warn-inconsistent-pred-order-clauses

Generate a warning if the order of the definitions does not match the order of the declarations for either the exported predicates and functions of the module, or for the nonexported predicates and functions of the module. Applies for definitions by Mercury clauses.

--warn-inconsistent-pred-order-foreign-procs

Generate a warning if the order of the definitions does not match the order of the declarations for either the exported predicates and functions of the module, or for the nonexported predicates and functions of the module. Applies for definitions by either Mercury clauses or foreign_proc pragmas.

--no-warn-non-contiguous-decls

Do not generate a warning if the mode declarations of a predicate or function don’t all immediately follow its predicate or function declaration.

--no-warn-non-contiguous-clauses

Do not generate a warning if the clauses of a predicate or function are not contiguous.

--warn-non-contiguous-foreign-procs

Generate a warning if the clauses and foreign_procs of a predicate or function are not contiguous.

--allow-non-contiguity-for name1,name2,...

Allow the clauses (or, with --warn-non-contiguous-foreign-procs, the clauses and/or foreign_proc pragmas) of the named predicates and/or functions to be intermingled with each other, but not with those or any other predicates or functions. This option may be specified more than once, with each option value specifying a distinct set of predicates and/or function names that may be intermingled. Each name must uniquely specify a predicate or a function.

--warn-non-stratification

Warn about possible non-stratification of the predicates and/or functions in the module. Non-stratification occurs when a predicate or function can call itself negatively through some path along its call graph.

--no-warn-simple-code

Disable warnings about constructs which are so simple that they are likely to be programming errors.

--warn-duplicate-calls

Warn about multiple calls to a predicate with the same input arguments.

--warn-implicit-stream-calls

Warn about calls to I/O predicates that could take explicit stream arguments, but do not do so.

--no-warn-smart-recompilation

Disable warnings from the smart recompilation system.

--no-warn-undefined-options-vars

--no-warn-undefined-options-variables

Do not warn about references to undefined variables in options files with ‘--make’.

--warn-suspicious-recursion

Warn about recursive calls which are likely to have problems, such as leading to infinite recursion.

--warn-non-tail-recursion type

Warn about any recursive calls that are not tail recursive. Implies the next two options. Warn about any recursive calls that are not tail recursive. type may be ‘self’, ‘self-and-mutual’ or ‘none’.

--warn-obvious-non-tail-recursion

Warn about recursive calls that are not tail calls even if they obviously cannot be tail calls, because they are followed by other recursive calls.

--no-warn-target-code

Disable warnings from the compiler used to process the target code (e.g. gcc).

--no-warn-up-to-date

Do not warn if targets specified on the command line with ‘--make’ are already up-to-date.

--no-warn-stubs

Disable warnings about procedures for which there are no clauses. Note that this option only has any effect if the ‘--allow-stubs’ option (see Language semantics options) is enabled.

--warn-dead-procs

--warn-dead-procedures

Warn about procedures which are never called.

--warn-dead-preds

--warn-dead-predicates

Warn about predicates that have no procedures which are ever called.

--no-warn-table-with-inline

Disable warnings about tabled procedures that also have a ‘pragma inline’ declaration.

--no-warn-non-term-special-preds

Do not warn about types that have user-defined equality or comparison predicates that cannot be proved to terminate. This option is only enabled when termination analysis is enabled. (See Termination analysis options for further details).

--no-warn-known-bad-format-calls

Do not warn about calls to string.format or io.format that the compiler knows for sure contain mismatches between the format string and the supplied values.

--no-warn-only-one-format-string-error

If a format string has more than one mismatch with the supplied values, generate a warning for all mismatches, not just the first. The later mismatches may be avalanche errors caused by earlier mismatches.

--warn-unknown-format-calls

Warn about calls to string.format, io.format or stream.string_writer.format for which the compiler cannot tell whether there are any mismatches between the format string and the supplied values.

--no-warn-obsolete

Do not warn about calls to predicates or functions that have been marked as obsolete.

--inform-ite-instead-of-switch

Generate informational messages for if-then-elses that could be replaced by switches.

--inform-incomplete-switch

Generate informational messages for switches that do not cover all the function symbols that the switched-on variable could be bound to.

--inform-incomplete-switch-threshold n

–inform-incomplete-switch-threshold <N> Have the --inform-incomplete-switch option generate its messages only for switches that do cover at least n percent of the function symbols that the switched-on variable could be bound to.

--no-warn-unresolved-polymorphism

Do not warn about unresolved polymorphism.

--warn-suspicious-foreign-procs

Warn about possible errors in the bodies of foreign procedures. When enabled, the compiler attempts to determine whether the success indicator for a foreign procedure is correctly set, and whether the foreign procedure body contains operations that are not allowed (for example, return statements in a C foreign procedure). Note that since the compiler’s ability to parse foreign language code is limited, some warnings reported by this option may be spurious, and some actual errors may not be detected at all.

--warn-suspicious-foreign-code

Warn about possible errors in the bodies of foreign code pragmas. Note that since the compiler’s ability to parse foreign language code is limited, some warnings reported by this option may be spurious, and some actual errors may not be detected at all.

--no-warn-state-var-shadowing

Do not warn about one state variable shadowing another.

--no-warn-unneeded-mode-specific-clause

Do not warn about clauses that needlessly specify the modes of their arguments.

--no-warn-suspected-occurs-check-failure

Do not warn about code that looks like it unifies a variable with a term that contains that same variable. Such code cannot succeed because it fails what is called the ‘occurs check’.

--warn-potentially-ambiguous-pragma

Generate warnings for pragmas that do not specify whether they are for a predicate or a function.

--warn-ambiguous-pragma

Generate warnings for pragmas that do not specify whether they are for a predicate or a function, when there is both a predicate and a function with the given name and arity.

--no-inform-inferred

Do not generate messages about inferred types or modes.

--no-inform-inferred-types

Do not generate messages about inferred types.

--no-inform-inferred-modes

Do not generate messages about inferred modes.

--inform-suboptimal-packing

Generate messages if the arguments of a data constructor could be packed more tightly if they were reordered.

--no-warn-redundant-coerce

Do not warn about redundant type conversions, i.e. when the type of a ‘coerce’ expression is the same as the argument type.

--warn-can-fail-function

Warn about functions that can fail.

--warn-unsorted-import-block

--warn-unsorted-import-blocks

Warn about two import and/or use declarations on the same line, or if a sequence of such declarations on consecutive lines are not sorted on module name.