lints

`rustc` lints.
git clone https://git.philomathiclife.com/repos/lints
Log | Files | Refs | README

1.1.0.txt (5346B)


      1 
      2 Available lint options:
      3     -W <foo>           Warn about <foo>
      4     -A <foo>           Allow <foo>
      5     -D <foo>           Deny <foo>
      6     -F <foo>           Forbid <foo> (deny, and deny all overrides)
      7 
      8 
      9 Lint checks provided by rustc:
     10 
     11                              name  default  meaning
     12                              ----  -------  -------
     13                      box-pointers  allow    use of owned (Box type) heap memory
     14                fat-ptr-transmutes  allow    detects transmutes of fat pointers
     15      missing-copy-implementations  allow    detects potentially-forgotten implementations of `Copy`
     16     missing-debug-implementations  allow    detects missing implementations of fmt::Debug
     17                      missing-docs  allow    detects missing documentation for public members
     18                     trivial-casts  allow    detects trivial casts which could be removed
     19             trivial-numeric-casts  allow    detects trivial casts of numeric types which could be removed
     20                       unsafe-code  allow    usage of `unsafe` code
     21                 unstable-features  allow    enabling unstable features
     22              unused-extern-crates  allow    extern crates that are never used
     23              unused-import-braces  allow    unnecessary braces around an imported item
     24             unused-qualifications  allow    detects unnecessarily qualified names
     25                    unused-results  allow    unused result of an expression in a statement
     26          variant-size-differences  allow    detects enums with widely varying variant sizes
     27                         dead-code  warn     detect unused, unexported items
     28                        deprecated  warn     detects use of #[deprecated] items
     29             drop-with-repr-extern  warn     use of #[repr(C)] on a type that implements Drop
     30                   improper-ctypes  warn     proper use of libc types in foreign modules
     31              non-camel-case-types  warn     types, variants, traits and type parameters should have camel case names
     32      non-shorthand-field-patterns  warn     using `Struct { x: x }` instead of `Struct { x }`
     33                    non-snake-case  warn     methods, functions, lifetime parameters and modules should have snake case names
     34            non-upper-case-globals  warn     static constants should have uppercase identifiers
     35              overflowing-literals  warn     literal out of range for its type
     36                   path-statements  warn     path statements with no effect
     37                 plugin-as-library  warn     compiler plugin used as ordinary library in non-plugin crate
     38             private-no-mangle-fns  warn     functions marked #[no_mangle] should be exported
     39         private-no-mangle-statics  warn     statics marked #[no_mangle] should be exported
     40                raw-pointer-derive  warn     uses of #[derive] with raw pointers are rarely correct
     41                   stable-features  warn     stable features found in #[feature] directive
     42           unconditional-recursion  warn     functions that cannot return without calling themselves
     43                     unknown-lints  warn     unrecognized lint attribute
     44                  unreachable-code  warn     detects unreachable code paths
     45                 unsigned-negation  warn     using an unary minus operator on unsigned type
     46                 unused-allocation  warn     detects unnecessary allocations that can be eliminated
     47                unused-assignments  warn     detect assignments that will never be read
     48                 unused-attributes  warn     detects attributes that were not used by the compiler
     49                unused-comparisons  warn     comparisons made useless by limits of the types involved
     50                   unused-features  warn     unused or unknown features found in crate-level #[feature] directives
     51                    unused-imports  warn     imports that are never used
     52                   unused-must-use  warn     unused result of a type flagged as #[must_use]
     53                        unused-mut  warn     detect mut variables which don't need to be mutable
     54                     unused-parens  warn     `if`, `match`, `while` and `return` do not need parentheses
     55                     unused-unsafe  warn     unnecessary use of an `unsafe` block
     56                  unused-variables  warn     detect variables which are not used in any way
     57                          warnings  warn     mass-change the level for lints which produce warnings
     58                        while-true  warn     suggest using `loop { }` instead of `while true { }`
     59               exceeding-bitshifts  deny     shift exceeds the type's number of bits
     60                mutable-transmutes  deny     mutating transmuted &mut T from &T may cause undefined behavior
     61             no-mangle-const-items  deny     const items will not have their symbols exported
     62               unknown-crate-types  deny     unknown crate type found in #[crate_type] directive
     63 
     64 
     65 Lint groups provided by rustc:
     66 
     67          name  sub-lints
     68          ----  ---------
     69     bad-style  non-camel-case-types, non-snake-case, non-upper-case-globals
     70        unused  unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unused-must-use, unused-unsafe, path-statements
     71 
     72 
     73 Compiler plugins can provide additional lints and lint groups. To see a listing of these, re-run `rustc -W help` with a crate filename.