The Warning Class Mnemonic Hierarchy

• ALLOC : Allocation/Deallocation Issues
  • DF : Double Free
  • DI : Double Initialization
  • FNP : Free Null Pointer
  • LEAK : Leak
  • MO : Misaligned Object
  • POSTINIT : Dynamic Allocation After Initialization
  • RPF : Return Pointer to Freed
  • SIZE
    • ADDOFLOW : Addition Overflow of Allocation Size
    • IOFLOW : Integer Overflow of Allocation Size
    • MULOFLOW : Multiplication Overflow of Allocation Size
    • SUBUFLOW : Subtraction Underflow of Allocation Size
    • TRUNC : Truncation of Allocation Size
  • TM : Type Mismatch
    • GlobalHandle on GMEM_FIXED Memory
    • GlobalLock on GMEM_FIXED Memory
    • GlobalUnlock on GMEM_FIXED Memory
    • LocalHandle on LMEM_FIXED Memory
    • LocalLock on LMEM_FIXED Memory
    • LocalUnlock on LMEM_FIXED Memory
    • Pool Mismatch
    • Type Mismatch
  • UAF : Use After Free
• BADFUNC : Inherently Unsafe Function
  • ABORT : Use of abort
  • ABORT_HANDLER_S : Use of abort_handler_s
  • ADDACCESSACE : Use of {AddAccessAllowedAce,AddAccessDeniedAce}
    • Use of AddAccessAllowedAce
    • Use of AddAccessDeniedAce
  • AFXPARSEURL : Use of AfxParseURL
  • ANTIDEBUG : Possible Anti-Debugging
  • ASCTIME_S : Use of asctime_s
  • ATOF : Use of atof
  • ATOI : Use of atoi
  • ATOL : Use of atol
  • ATOLL : Use of atoll
  • BO
    • GETOPT : Use of getopt
    • GETPASS : Use of getpass
    • GETS : Use of gets
    • GETWD : Use of getwd
    • OEMTOCHAR : Use of {OemToAnsi,OemToChar}
      • Use of OemToAnsi
      • Use of OemToChar
    • REALPATH : Use of realpath
    • RECVMSG : Use of recvmsg
    • STRCAT : Use of strcat
    • STRCATCHAINW : Use of StrCatChainW
    • STRCHR : Use of strchr
    • STRCMP : Use of strcmp
    • STRCOLL : Use of strcoll
    • STRCPY : Use of strcpy
    • STRCSPN : Use of strcspn
    • STRLEN : Use of strlen
    • STRPBRK : Use of strpbrk
    • STRRCHR : Use of strrchr
    • STRSPN : Use of strspn
    • STRSTR : Use of strstr
    • STRTOK : Use of strtok
    • STRTRNS : Use of strtrns
    • SYSLOG : Use of syslog
  • BSEARCH : Use of bsearch
  • BSEARCH_S : Use of bsearch_s
  • CATOPEN : Use of catopen
  • CHROOT : Use of chroot
  • CONSTRAINT_HANDLER_T : Use of constraint_handler_t
  • CREATEFILE : Use of CreateFile
  • CREATEPROCESS : Use of CreateProcess
  • CREATETHREAD : Use of CreateThread
  • CRYPT : Use of crypt
  • CTIME_S : Use of ctime_s
  • CUSERID : Use of cuserid
  • EXIT : Use of exit
  • FENV_H : Use of <fenv.h> Exception Handling Function
  • FLOAT
    • DREM : Use of drem
    • GAMMA : Use of gamma
  • FOPEN_S : Use of fopen_s
  • FORK : Use of fork
  • FORMATMESSAGE : Use of FormatMessage
  • FPRINTF_S : Use of fprintf_s
  • FREOPEN_S : Use of freopen_s
  • FSCANF_S : Use of fscanf_s
  • FWPRINTF_S : Use of fwprintf_s
  • FWSCANF_S : Use of fwscanf_s
  • GETENV : Use of getenv
  • GETENV_S : Use of getenv_s
  • GETLOGIN : Use of getlogin
  • GETS_S : Use of gets_s
  • GMTIME_S : Use of gmtime_s
  • IGNORE_HANDLER_S : Use of ignore_handler_s
  • LOADMODULE : Use of LoadModule
  • LOCALE
    • GLOBAL : Use of std::locale::global
  • LOCALTIME_S : Use of localtime_s
  • LONGJMP : Use of longjmp
  • MBSRTOWCS_S : Use of mbsrtowcs_s
  • MBSTOWCS_S : Use of mbstowcs_s
  • MEMCMP : Use of memcmp
  • MEMCPY_S : Use of memcpy_s
  • MEMMOVE_S : Use of memmove_s
  • MEMSET : Use of memset
  • MEMSET_S : Use of memset_s
  • MOVEFILE : Use of MoveFile
  • PATH
    • AFXLOADLIBRARY : Use of AfxLoadLibrary
    • COLOADLIBRARY : Use of CoLoadLibrary
    • EXECLP : Use of execlp
    • EXECVP : Use of execvp
    • LOADLIBRARY : Use of LoadLibrary
    • POPEN : Use of popen
    • SHCREATEPROCESSASUSERW : Use of SHCreateProcessAsUserW
    • SHELLEXECUTE : Use of ShellExecute
    • SYSTEM : Use of system
    • _EXEC : Use of _exec
    • _SPAWN : Use of _spawn
  • PRINTF_S : Use of printf_s
  • PUTENV : Use of putenv
  • QSORT : Use of qsort
  • QSORT_S : Use of qsort_s
  • RANDOM
    • RAND : Use of rand
    • RAND48 : Use of rand48 Function
    • RANDOM : Use of random
  • REALLOC : Use of realloc
  • SCANF_S : Use of scanf_s
  • SETJMP : Use of setjmp
  • SETLOCALE : Use of setlocale
  • SETUID : Use of setuid
  • SET_CONSTRAINT_HANDLER_S : Use of set_constraint_handler_s
  • SIGNAL : Use of signal
  • SNPRINTF_S : Use of snprintf_s
  • SNWPRINTF_S : Use of snwprintf_s
  • SPRINTF_S : Use of sprintf_s
  • SSCANF_S : Use of sscanf_s
  • STDIO_H : Use of <stdio.h> Input/Output
  • STDLIB_H_MEM : Use of <stdlib.h> Allocator/Deallocator
  • STRCAT_S : Use of strcat_s
  • STRCPY_S : Use of strcpy_s
  • STRERRORLEN_S : Use of strerrorlen_s
  • STRERROR_S : Use of strerror_s
  • STRNCAT_S : Use of strncat_s
  • STRNCPY_S : Use of strncpy_s
  • STRNLEN_S : Use of strnlen_s
  • STRTOK_S : Use of strtok_s
  • SWPRINTF_S : Use of swprintf_s
  • SWSCANF_S : Use of swscanf_s
  • TEMP
    • GETTEMPFILENAME : Use of GetTempFileName
    • MKSTEMP : Use of mkstemp
    • MKTEMP : Use of mktemp
    • TMPFILE : Use of tmpfile
    • TMPNAM : Use of tmpnam
  • TIME_H : Use of <time.h> Time/Date Function
  • TMPFILE_S : Use of tmpfile_s
  • TMPNAM_S : Use of tmpnam_s
  • TTYNAME : Use of ttyname
  • T_OPEN : Use of t_open
  • VFORK : Use of vfork
  • VFPRINTF_S : Use of vfprintf_s
  • VFSCANF_S : Use of vfscanf_s
  • VFWPRINTF_S : Use of vfwprintf_s
  • VFWSCANF_S : Use of vfwscanf_s
  • VPRINTF_S : Use of vprintf_s
  • VSCANF_S : Use of vscanf_s
  • VSNPRINTF_S : Use of vsnprintf_s
  • VSNWPRINTF_S : Use of vsnwprintf_s
  • VSPRINTF_S : Use of vsprintf_s
  • VSSCANF_S : Use of vsscanf_s
  • VSWPRINTF_S : Use of vswprintf_s
  • VSWSCANF_S : Use of vswscanf_s
  • VWPRINTF_S : Use of vwprintf_s
  • VWSCANF_S : Use of vwscanf_s
  • WCHAR_H : Use of <wchar.h> Input/Output
  • WCRTOMB_S : Use of wcrtomb_s
  • WCSCAT_S : Use of wcscat_s
  • WCSCPY_S : Use of wcscpy_s
  • WCSNCAT_S : Use of wcsncat_s
  • WCSNCPY_S : Use of wcsncpy_s
  • WCSNLEN_S : Use of wcsnlen_s
  • WCSRTOMBS_S : Use of wcsrtombs_s
  • WCSTOK_S : Use of wcstok_s
  • WCSTOMBS_S : Use of wcstombs_s
  • WCTOMB_S : Use of wctomb_s
  • WEAKCRYPTO : Weak Cryptography
  • WINEXEC : Use of WinExec
  • WMEMCPY_S : Use of wmemcpy_s
  • WMEMMOVE_S : Use of wmemmove_s
  • WPRINTF_S : Use of wprintf_s
  • WSCANF_S : Use of wscanf_s
  • XML_EXTERNALENTITYPARSERCREATE : Use of XML_ExternalEntityParserCreate
• BADMACRO : Inherently Unsafe Macro
  • L_TMPNAM_S : Use of L_tmpnam_s
  • NULL : Use of NULL
  • OFFSETOF : Use of offsetof
  • STDARG_H : Use of <stdarg.h> Feature
  • STDINT_H_ICONST : Use of <stdint.h> Small Integer Constant Macro
  • STDIO_H : Use of <stdio.h> Input/Output Macro
  • STDLIB_H_MEM : Use of <stdlib.h> Allocator/Deallocator Macro
  • TMP_MAX_S : Use of TMP_MAX_S
  • WCHAR_H : Use of <wchar.h> Input/Output Macro
  • WEAK_CRYPTO : Use of Weak Cryptographic Algorithm
• BUILD : Build or Compilation Issues
  • WALL : Not All Warnings Are Enabled
  • WERROR : Warnings Not Treated As Errors
• CONCURRENCY : Timing-Sensitive Interaction of Processes/Threads
  • BADFUNC
    • CNDSIGNAL : Use of Condition Variable Signal
    • CNDWAIT : Use of Condition Variable Wait
    • DELAY : Task Delay Function
    • PTHREAD_KILL : Use of pthread_kill
  • C_ATOMIC : Use of C Atomic
    • DAF : Direct Access to Field of C Atomic Object
    • INIT : Inappropriate C Atomic Initialization
    • MO : Risky Atomic Memory Order
    • VOID : Void C Atomic
  • C_THREAD
    • ISD : Inappropriate Storage Duration
  • DATARACE : Data Race
  • DEADLOCK : Deadlock
  • DL : Double Lock
  • DTC : Dynamic Thread Creation
  • DU : Double Unlock
  • LOCALARG : Local Variable Passed to Thread
  • LOCK
    • MISMATCH : Lock/Unlock Mismatch
    • NESTED : Nested Locks
    • NOLOCK : Missing Lock Acquisition
    • NOUNLOCK : Missing Lock Release
    • ORDER : Conflicting Lock Order
    • TWICE : Locked Twice
    • UNKNOWN : Unknown Lock
  • MAA : Multiple Accesses of Atomic
  • STARVE
    • BLOCKING : Blocking in Critical Section
  • THREADLOCAL : Use of Thread Local
  • TL : Try-lock that will never succeed
  • TNJ : Thread is not Joinable
• CSHARP : C# Warning Classes
  • ALLOC
    • LEAK
      • NOTCLOSED : Closeable Not Closed (C#)
      • NOTSTORED : Closeable Not Stored (C#)
  • ARITH
    • FPEQUAL : Floating Point Equality (C#)
    • OFLOW : Cast: int Computation to long (C#)
  • CAST
    • FTRUNC : Cast: Integer to Floating Point (C#)
  • CLASS
    • ACCESS
      • BYPASS : Reflection Bypasses Member Accessibility (C#)
      • MODIFY : Reflection Modifies Member Accessibility (C#)
    • ACIC : Ambiguous Call from Inner Class (C#)
    • CAST : Risky Class Cast (C#)
      • ARRSTORE : Risky array store (C#)
      • USELESS : Useless Class Cast (C#)
    • CLONE
      • CNC : clone Non-cloneable (C#)
      • NF : clone not final (C#)
      • SCNC : clone Subclass of Non-clonable (C#)
    • IOF
      • BAD : Inappropriate Instanceof (C#)
      • F : Instanceof Always False (C#)
      • T : Instanceof Always True (C#)
    • MCS : Missing Call to super (C#)
    • METH
      • NF : Method Should be final (C#)
    • SER
      • DESER : Deserializable Class (C#)
      • ENON : Nonserializable Field Element (C#)
      • FNON : Nonserializable Field (C#)
      • OCNON : Nonserializable Outer Class (C#)
    • STATICMOD : Static Field Assigned Non-Static (C#)
    • VIS
      • FIELD : Field Too Visible (C#)
      • METH
        • PRIV : Method Should be private (C#)
      • SFIELD : Static Field Too Visible (C#)
  • COMPARE
    • CTO
      • ASSYM : Asymmetric compareTo (C#)
      • NONCOMP : compareTo in Non-Comparable Class (C#)
      • NONOBJ : Non-Object compareTo Parameter (C#)
    • EMPTYSTR : Comparison to Empty String (C#)
    • EQ : Should Use equals() Instead of == (C#)
    • EQARRAY : equals on Array (C#)
    • EQUALS : Should Use == Instead of equals() (C#)
      • CN : Comparison to Class Names (C#)
  • CONCURRENCY
    • LOCK
      • DCL : Double-Checked Locking (C#)
      • ICS : Impossible Client Side Locking (C#)
      • ISTR : Synchronization on Interned String (C#)
      • SCTB : Synchronous Call to Thread Body (C#)
      • STATIC : Synchronization on static (C#)
      • USELESS : Useless Synchronization (C#)
    • STARVE
      • BLOCKING : Blocking in Critical Section (C#)
    • SYNC
      • MSS : Missing synchronized Statement (C#)
    • UG
      • FIELD : Unguarded Field (C#)
      • METH : Unguarded Method (C#)
      • PARAM : Unguarded Parameter (C#)
    • VOLATILE : Useless volatile Modifier (C#)
  • CRYPTO
    • BASE64 : Unsafe Base64 Encoding (C#)
    • CADRC : Cryptographic Algorithm with Risky Default Cipher (C#)
    • CARC : Cryptographic Algorithm with Weak Cipher (C#)
    • CAWH : Cryptographic Algorithm with Weak Hash (C#)
    • DEPRECATED : Deprecated Cryptography Provider (C#)
    • KEY : Insecure Key Derivation (C#)
    • MRCS : Missing Required Cryptographic Step (C#)
    • RA : Risky Cryptographic Algorithm (C#)
    • RCA : Risky Cipher Algorithm (C#)
    • RCF : Risky Cipher Field (C#)
    • RF : Risky Cryptographic Field (C#)
    • SALT : Inadequate Salt (C#)
    • VALUE : Weak Cryptographic Value (C#)
    • WHA : Weak Hash Algorithm (C#)
    • WHAF : Weak Hash Algorithm Field (C#)
    • WIV : Weak Initialization Vector Value (C#)
    • WIVF : Weak Initialization Vector Field (C#)
  • DEBUG
    • CALL : Debug Call (C#)
    • CEDF : Class Enables Debug Features (C#)
    • ID : Exception Information Disclosure (C#)
    • LOG : Debug Warning (C#)
    • MEDF : Method Enables Debug Features (C#)
  • DEEPNULL
    • DEREF : Null Pointer Dereference (deep) (C#)
    • EFIELD : Field Element may be null (deep) (C#)
    • FIELD : Field may be null (deep) (C#)
    • PARAM
      • ACTUAL : null Passed to Method (deep) (C#)
      • EACTUAL : Actual Parameter Element may be null (C#)
    • RET
      • EMETH : Return Value may Contain null Element (C#)
      • METH : Return Value may be null (C#)
    • UTEST : Useless null Test (C#)
      • FIELD : Useless null Test of Field (C#)
      • PARAM : Useless null Test of Parameter (C#)
      • RV : Useless null Test of Return Value (C#)
  • FUNCS
    • INFREC : Potential Infinite Recursion (C#)
    • IRV : Ignored Return Value (C#)
      • PURE : Ignored Return Value for Pure Function (C#)
    • RED
      • INT : Redundant Call for Integral Argument (C#)
      • STR : Redundant Call for String Argument (C#)
  • HARDCODED
    • FNAME : Hardcoded Filename (C#)
    • IP : Hardcoded IP Address (C#)
    • KEY : Hardcoded Cryptographic Key (C#)
    • PASSWD : Hardcoded Password (C#)
      • FILE : Password in Property File (C#)
    • SEED : Hardcoded Random Seed (C#)
  • ID
    • BADOVERRIDE : Non-overriding Method Signature (C#)
    • CASE
      • METHOD : Method Names Differ Only in Case (C#)
    • SHADOW : Shadowed Identifier (C#)
    • STYLE : Naming Style Violation (C#)
  • IDEF
    • CTOEQ : compareTo/equals mismatch (C#)
    • CTONOEQ : compareTo without equals (C#)
    • EQUALS
      • NONOBJ : equals Parameter Should Be Object (C#)
    • EQUALSNOHC : Defines equals but not hashCode (C#)
    • HCNOEQUALS : Defines hashCode but not equals (C#)
    • NOEQUALS : Missing Equals Override (C#)
  • INSEC
    • CERT
      • RS : Certificate Added to Root Store (C#)
    • DIV : Disabled Input Validation (C#)
    • DTP : Deprecated Transfer Protocol (C#)
    • EAR : Execution After Redirect (C#)
    • HIC : Hostname in Condition (C#)
    • LDAP
      • ANON : Anonymous LDAP Authentication (C#)
    • MAA : Missing Authentication Annotation (C#)
    • MDSS : Method Disables Security Setting (C#)
    • SAC : Security Annotation Conflict (C#)
    • SS : Use of Same Seed (C#)
    • USET : Unsafe Session Expiration Time (C#)
  • IO
    • INJ
      • CODE : Code Injection (C#)
      • COMMAND : Command Injection (C#)
      • DENIAL : DOS Injection (C#)
      • DLL : DLL Injection (C#)
      • FMT : Format String Injection (C#)
      • SQL : SQL Injection (C#)
      • XSS : Cross Site Scripting (C#)
        • EMWP : Cross Site Scripting In Error Message Web Page (C#)
    • TAINT
      • ADDR : Tainted Network Address (C#)
      • BUNDLE : Tainted Bundle (C#)
      • CONTROL : Tainted Control (C#)
      • DEVICE : Tainted Hardware Device Property (C#)
      • EVAL : Tainted Expression Evaluation (C#)
      • HTTP : Tainted HTTP Response (C#)
        • OR : Open Redirect (C#)
      • LDAP
        • ATTR : Tainted LDAP Attribute (C#)
        • FILTER : Tainted LDAP Filter (C#)
      • LOG : Tainted Log (C#)
      • MESSAGE : Tainted Message (C#)
      • PATH : Tainted Path (C#)
      • REFLECTION : Reflection Injection (C#)
      • REGEX : Tainted Regular Expression (C#)
      • RESOURCE : Tainted Resource (C#)
      • SESSION : Tainted Session (C#)
      • SIZE : Tainted Allocation Size (C#)
      • TRUSTED : Tainted @Trusted Value (C#)
      • URL : Tainted URL (C#)
      • XAML : Tainted XAML (C#)
      • XML : Tainted XML (C#)
      • XPATH : Tainted Xpath (C#)
  • LIB
    • HTTP
      • COOKIE : Insecure Cookie (C#)
    • RAND
      • FUNC : Insecure Random Number Generator (C#)
      • LEGACY
        • GEN : Legacy Random Generator (C#)
      • NEW : Single-use Random Number Generator (C#)
    • XML
      • INSEC_XSLT : Insecure XSLT Execution (C#)
      • XXE : Possible XML External Entity Reference (C#)
  • MATH
    • ABSRAND : Abs on random (C#)
    • APPROX
      • E : Approximate e Constant (C#)
      • PI : Approximate pi Constant (C#)
  • NULL
    • DEREF : Null Pointer Dereference (C#)
    • PARAM
      • ACTUAL : Null Parameter Dereference (C#)
    • RET
      • ARRAY : Return null Array (C#)
      • NONNULL : Method Should Not Return null (C#)
      • UNCHECKED : Call Might Return Null (C#)
  • REDUNDANT
    • EQF : Impossible reference comparison (C#)
      • TYPE : == Always Fails Because Types Always Different (C#)
    • EQUALSF : equals Always Fails (C#)
  • STRUCT
    • ARCHIVE
      • EZF : Empty zip File Archived (C#)
    • BW
      • AND : Bitwise AND on Boolean (C#)
      • ANDC : Bitwise AND on Boolean Constant (C#)
      • ANDI : Inefficient Bitwise AND (C#)
      • OR : Bitwise OR on Boolean (C#)
      • ORC : Bitwise OR on Boolean Constant (C#)
      • ORI : Inefficient Bitwise OR (C#)
    • CONDASSIG : Assignment in Conditional (C#)
    • DUPD : Unchecked Parameter Dereference (deep) (C#)
    • EBS : Empty Branch Statement (C#)
    • EXCP
      • EEH : Empty Exception Handler (C#)
      • GEH : Generic Exception Handler (C#)
      • INAPP : Inappropriate Exception Handler (C#)
    • RC : Redundant Condition (C#)
    • UA : Useless Assignment (C#)
      • DEFAULT : Useless Assignment to Default (C#)
    • UC
      • INSTR : Unreachable Instruction (C#)
    • UNFLD : Unnecessary Field (C#)
    • UPD : Unchecked Parameter Dereference (C#)
    • UPED : Unchecked Parameter Element Dereference (deep) (C#)
    • URFIELD : Field Never Read (C#)
    • UUCLASS : Unused Class (C#)
    • UUFIELD : Unused Field (C#)
    • UUMETH : Unused Method (C#)
    • UUOBJ : Unused Object (C#)
    • UUVAL
      • ACTUAL : Unused Value: Actual Parameter (C#)
      • PARAM : Unused Value: Write to Parameter (C#)
      • VAR : Unused Value: Variable (C#)
    • UWFIELD : Field Never Written (C#)
  • TYPE
    • ARRAYTOSTRING : toString on Array (C#)
    • MCF : Mutable Constant Field (C#)
    • ME : Mutable Enumeration (C#)
    • MPSFA : Mutable Public Static Final Array (C#)
• DIAG : Diagnostics
  • MISRA
    • ETYPE : Essential Type Diagnostic
  • SIGHAND
    • ENTRY : Signal Handler Entry Point
  • THREAD
    • ENTRY : Thread Entry Point
  • UNEX
    • CALL : Unexercised Call
    • COMP : Unexercised Computation
    • COND : Unexercised Conditional
    • CONTROL : Unexercised Control Flow
    • DATA : Unexercised Data Flow
• GO : Go Warning Classes
  • CONCURRENCY
    • CTTFOS : Called 'testing.T.FailNow' or 'SkipNow' in a Goroutine, Which Isn't Allowed (Staticcheck)
    • DLRALL : Deferred 'Lock' Right After Locking, Likely Meant to Defer 'Unlock' Instead (Staticcheck)
    • ECSDYM : Empty Critical Section, Did You Mean to Defer the Unlock? (Staticcheck)
    • SWACIT : 'sync.WaitGroup.Add' Called Inside the Goroutine, Leading to a Race Condition (Staticcheck)
  • CORRECTNESS
    • ATNM : Assignment to Nil Map (Staticcheck)
    • DCBCFA : Deferring 'Close' Before Checking for a Possible Error (Staticcheck)
    • DIILWN : Defers in Infinite Loops Will Never Execute (Staticcheck)
    • FSWAED : "for { Select { ..." With an Empty Default Branch Spins (Staticcheck)
    • IPC : Invalid Printf Call (Staticcheck)
    • IRC : Infinite Recursive Call (Staticcheck)
    • IST : Invalid Struct Tag (Staticcheck)
    • ITA : Impossible Type Assertion (Staticcheck)
    • PNPD : Possible Nil Pointer Dereference (Staticcheck)
    • POSTFE : Passing Odd-sized Slice to Function Expecting Even Size (Staticcheck)
    • TEFLFS : The Empty for Loop ("for {}") Spins and Can Block the Scheduler (Staticcheck)
    • TFRTFO : The Finalizer References the Finalized Object, Preventing Garbage Collection (Staticcheck)
  • DEADCODE
    • AFAIOB : A Function Argument Is Overwritten Before Its First Use (Staticcheck)
    • AIEICH : An If Else If Chain Has Repeated Conditions and No Side-effects; If the Condition Didn't Match the First Time, It Won't Match the Second Time, Either (Staticcheck)
    • AVATAV : A Value Assigned to a Variable Is Never Read Before Being Overwritten. Forgotten Error Check or Dead Code? (Staticcheck)
    • BOHIEO : Binary Operator Has Identical Expressions on Both Sides (Staticcheck)
    • BSWNED : Break Statement With No Effect. Did You Mean to Break Out of an Outer Loop? (Staticcheck)
    • CAVANE : Comparing a Value Against NaN Even Though No Value Is Equal to NaN (Staticcheck)
    • CBOSAX : Certain Bitwise Operations, Such As 'x ^ 0', Do Not Do Anything Useful (Staticcheck)
    • CFIRVF : Checking for Impossible Return Value From a Builtin Function (Staticcheck)
    • CFLMCO : Calling Functions Like 'math.Ceil' on Floats Converted From Integers Doesn't Do Anything Useful (Staticcheck)
    • CNVAN : Checking Never-nil Value Against Nil (Staticcheck)
    • CRGORG : Comparing 'runtime.GOOS' or 'runtime.GOARCH' Against Impossible Value (Staticcheck)
    • CTAOAV : Comparing the Address of a Variable Against Nil (Staticcheck)
    • CUVANV : Comparing Unsigned Values Against Negative Values Is Pointless (Staticcheck)
    • DTRVOA : Discarding the Return Values of a Function Without Side Effects, Making the Call Pointless (Staticcheck)
    • FATWNB : Field Assignment That Will Never Be Observed. Did You Mean to Use a Pointer Receiver? (Staticcheck)
    • GCCENZ : Go Constants Cannot Express Negative Zero (Staticcheck)
    • IAAGRN : Ineffective Attempt at Generating Random Number (Staticcheck)
    • IAASS : Ineffective Attempt at Sorting Slice (Staticcheck)
    • ICOIVW : Impossible Comparison of Interface Value With Untyped Nil (Staticcheck)
    • IDOLTR : Integer Division of Literals That Results in Zero (Staticcheck)
    • MIBCIT : Multiple, Identical Build Constraints in the Same File (Staticcheck)
    • NABTBI : Negating a Boolean Twice ('!!b') Is the Same As Writing 'b'. This Is Either Redundant, or a Typo. (Staticcheck)
    • NUUQRA : '(*net Url.URL).Query' Returns a Copy, Modifying It Doesn't Change the URL (Staticcheck)
    • SOV : Self-assignment of Variables (Staticcheck)
    • TLEUAO : The Loop Exits Unconditionally After One Iteration (Staticcheck)
    • TROAWN : The Result of 'append' Will Never Be Observed Anywhere (Staticcheck)
    • TVITLC : The Variable in the Loop Condition Never Changes, Are You Incrementing the Wrong Variable? (Staticcheck)
    • UCCIAT : Unreachable Case Clause in a Type Switch (Staticcheck)
    • X1IAZ : 'x % 1' Is Always Zero (Staticcheck)
    • XAIETX : "x = Append(y)" Is Equivalent to "x = Y" (Staticcheck)
    • XGSTXI : '&*x' Gets Simplified to 'x', It Does Not Copy 'x' (Staticcheck)
  • DUBIOUS
    • DADTSB : Deleting a Directory That Shouldn't Be Deleted (Staticcheck)
    • DBSOAF : Dubious Bit Shifting of a Fixed Size Integer Value (Staticcheck)
    • DIRLMN : Defers in Range Loops May Not Run When You Expect Them to (Staticcheck)
    • EBIAIO : Empty Body in an If or Else Branch (Staticcheck)
    • EBOATA : 'else' Branch of a Type Assertion Is Probably Not Reading the Right Value (Staticcheck)
    • OTFCHA : Only the First Constant Has an Explicit Type (Staticcheck)
    • TTMASW : Trying to Marshal a Struct With No Public Fields Nor Custom Marshaling (Staticcheck)
    • UANOFT : Using a Non-octal 'os.FileMode' That Looks Like It Was Meant to Be in Octal. (Staticcheck)
  • PERFORMANCE
    • CASTAS : Converting a String to a Slice of Runes Before Ranging Over It (Staticcheck)
    • ISCWST : Inefficient String Comparison With 'strings.ToLower' or 'strings.ToUpper' (Staticcheck)
    • MAOOWI : Missing an Optimization Opportunity When Indexing Maps By Byte Slices (Staticcheck)
    • SNVISP : Storing Non-pointer Values in 'sync.Pool' Allocates Memory (Staticcheck)
    • UIWTWB : Using Io.WriteString to Write '[]byte' (Staticcheck)
    • URMORI : Using 'regexp.Match' or Related in a Loop, Should Use 'regexp.Compile' (Staticcheck)
  • SIMPLIFICATION
    • DUFSXU : Don't Use 'fmt.Sprintf("%s", X)' Unnecessarily (Staticcheck)
    • DUUOTB : Drop Unnecessary Use of the Blank Identifier (Staticcheck)
    • EWOS : Elaborate Way of Sleeping (Staticcheck)
    • MVDAA : Merge Variable Declaration and Assignment (Staticcheck)
    • OCWBC : Omit Comparison With Boolean Constant (Staticcheck)
    • ODSI : Omit Default Slice Index (Staticcheck)
    • ORCF : Omit Redundant Control Flow (Staticcheck)
    • ORNCAL : Omit Redundant Nil Check Around Loop (Staticcheck)
    • ORNCIT : Omit Redundant Nil Check in Type Assertion (Staticcheck)
    • ORNCOS : Omit Redundant Nil Check on Slices (Staticcheck)
    • RCTBCW : Replace Call to 'bytes.Compare' With 'bytes.Equal' (Staticcheck)
    • RCTNHC : Redundant Call to 'net Http.CanonicalHeaderKey' in Method Call on 'net Http.Header' (Staticcheck)
    • RCTSIW : Replace Call to 'strings.Index' With 'strings.Contains' (Staticcheck)
    • RFLWCT : Replace for Loop With Call to Copy (Staticcheck)
    • RMTWST : Replace Manual Trimming With 'strings.TrimPrefix' (Staticcheck)
    • ROTSD : Range Over the String Directly (Staticcheck)
    • RTNSWT : Replace 'time.Now().Sub(x)' With 'time.Since(x)' (Staticcheck)
    • RXSNWT : Replace 'x.Sub(time.Now())' With 'time.Until(x)' (Staticcheck)
    • SECWFE : Simplify Error Construction With 'fmt.Errorf' (Staticcheck)
    • SMCBOR : Simplify "make" Call By Omitting Redundant Arguments (Staticcheck)
    • SRBE : Simplify Returning Boolean Expression (Staticcheck)
    • SREBUR : Simplify Regular Expression By Using Raw String Literal (Staticcheck)
    • TATCT : Type Assertion to Current Type (Staticcheck)
    • UASATC : Use a Single 'append' to Concatenate Two Slices (Staticcheck)
    • UATCIO : Use a Type Conversion Instead of Manually Copying Struct Fields (Staticcheck)
    • UBBSOB : Use 'bytes.Buffer.String' or 'bytes.Buffer.Bytes' (Staticcheck)
    • UCFSE : Use "copy" for Sliding Elements (Staticcheck)
    • UCWOPF : Unnecessarily Complex Way of Printing Formatted String (Staticcheck)
    • UFFIL : Use "for { ... }" for Infinite Loops (Staticcheck)
    • UGACTD : Unnecessary Guard Around Call to "delete" (Staticcheck)
    • UGAMA : Unnecessary Guard Around Map Access (Staticcheck)
    • UPCSOR : Use Plain Channel Send or Receive Instead of Single-case Select (Staticcheck)
    • UROTAT : Use Result of Type Assertion to Simplify Cases (Staticcheck)
    • USISFA : Use 'sort.Ints(x)', 'sort.Float64s(x)', and 'sort.Strings(x)' (Staticcheck)
    • UUOFS : Unnecessary Use of 'fmt.Sprint' (Staticcheck)
  • STDLIB
    • AAT64V : Atomic Access to 64-bit Variable Must Be 64-bit Aligned (Staticcheck)
    • ANCCIB : A Nil 'context.Context' Is Being Passed to a Function, Consider Using 'context.TODO' Instead (Staticcheck)
    • ASCCDC : A String Cutset Contains Duplicate Characters (Staticcheck)
    • CMCOF : Cannot Marshal Channels or Functions (Staticcheck)
    • CUWOSN : Channels Used With 'os Signal.Notify' Should Be Buffered (Staticcheck)
    • IAICTA : Invalid Argument in Call to a 'strconv' Function (Staticcheck)
    • IFATEC : Invalid First Argument to 'exec.Command' (Staticcheck)
    • IFITP : Invalid Format in 'time.Parse' (Staticcheck)
    • IINPTU : It Is Not Possible to Use '(*time.Timer).Reset''s Return Value Correctly (Staticcheck)
    • IKICTC : Inappropriate Key in Call to 'context.WithValue' (Staticcheck)
    • IRE : Invalid Regular Expression (Staticcheck)
    • ISSIBC : 'io.Seeker.Seek' Is Being Called With the Whence Constant As the First Argument, but It Should Be the Second (Staticcheck)
    • IT : Invalid Template (Staticcheck)
    • IUINUP : Invalid URL in 'net Url.Parse' (Staticcheck)
    • MTBIAI : Modifying the Buffer in an 'io.Writer' Implementation (Staticcheck)
    • NKIHHM : Non-canonical Key in 'http.Header' Map (Staticcheck)
    • NVPTUO : Non-pointer Value Passed to 'Unmarshal' or 'Decode' (Staticcheck)
    • OBSPTA : Overlapping Byte Slices Passed to an Encoder (Staticcheck)
    • PWDFAA : 'Printf' With Dynamic First Argument and No Further Arguments (Staticcheck)
    • RRFCWN : '(*regexp.Regexp).FindAll' Called With 'n == 0', Which Will Always Return Zero Results (Staticcheck)
    • SRCWN0 : 'strings.Replace' Called With 'n == 0', Which Does Nothing (Staticcheck)
    • SSCOBU : 'sort.Slice' Can Only Be Used on Slices (Staticcheck)
    • SSUCIT : Suspiciously Small Untyped Constant in 'time.Sleep' (Staticcheck)
    • TASTCB : Trapping a Signal That Cannot Be Trapped (Staticcheck)
    • UADFVC : Using a Deprecated Function, Variable, Constant or Field (Staticcheck)
    • UAIHPW : Using an Invalid Host:port Pair With a 'net.Listen'-related Function (Staticcheck)
    • UATFIE : Unsupported Argument to Functions in 'encoding Binary' (Staticcheck)
    • UBETCT : Using 'bytes.Equal' to Compare Two 'net.IP' (Staticcheck)
    • UTTIAW : Using 'time.Tick' in a Way That Will Leak. Consider Using 'time.NewTicker', and Only Use 'time.Tick' in Tests, Commands and Endless Functions (Staticcheck)
    • VMITSP : Various Methods in the "strings" Package Expect Valid UTF-8, but Invalid Input Is Provided (Staticcheck)
  • STYLE
    • AFEVSB : A Function's Error Value Should Be Its Last Return Value (Staticcheck)
    • ASDCSB : A Switch's Default Case Should Be the First or Last Case (Staticcheck)
    • AZACCI : Avoid Zero-width and Control Characters in String Literals (Staticcheck)
    • DIAD : Dot Imports Are Discouraged (Staticcheck)
    • DUYC : Don't Use Yoda Conditions (Staticcheck)
    • IFES : Incorrectly Formatted Error String (Staticcheck)
    • IOMPC : Incorrect or Missing Package Comment (Staticcheck)
    • ITSPMT : Importing the Same Package Multiple Times (Staticcheck)
    • PCI : Poorly Chosen Identifier (Staticcheck)
    • PCNFEV : Poorly Chosen Name for Error Variable (Staticcheck)
    • PCNFVO : Poorly Chosen Name for Variable of Type 'time.Duration' (Staticcheck)
    • PCRN : Poorly Chosen Receiver Name (Staticcheck)
    • RTIVD : Redundant Type in Variable Declaration (Staticcheck)
    • SUCFHE : Should Use Constants for HTTP Error Codes, Not Magic Numbers (Staticcheck)
    • TDOAEF : The Documentation of an Exported Function Should Start With the Function's Name (Staticcheck)
    • TDOAET : The Documentation of an Exported Type Should Start With Type's Name (Staticcheck)
    • TDOAEV : The Documentation of an Exported Variable or Constant Should Start With Variable's Name (Staticcheck)
    • UCMRN : Use Consistent Method Receiver Names (Staticcheck)
  • TESTING
    • ATBNIB : Assigning to 'b.N' in Benchmarks Distorts the Results (Staticcheck)
    • TDCOEH : 'TestMain' Doesn't Call 'os.Exit', Hiding Test Failures (Staticcheck)
  • UC
    • UC : Unused Code (Staticcheck)
• HARDCODED : Hardcoding of Sensitive Values
  • AUTH : Hardcoded Authentication
  • DNS : Hardcoded DNS Name
  • KEY : Hardcoded Crypto Key
  • SALT : Hardcoded Crypto Salt
  • SEED : Hardcoded Seed in PRNG
• IO : Input/Output on Files and Sockets
  • BRAW : File Open for Both Read and Write
  • DC : Double Close
  • FILEDEREF : FILE* Dereference
  • INJ
    • COMMAND : Command Injection
    • FMT : Format String Injection
    • LDAP : LDAP Injection
    • LIB : Library Injection
    • SQL : SQL Injection
  • IOWOP : Input After Output Without Positioning
  • NEGFD : Negative file descriptor
  • OIWOP : Output After Input Without Positioning
  • RACE : File System Race Condition
  • SOCK
    • REUSE : Use of SO_REUSEADDR
    • STATE : Socket In Wrong State
  • TAINT
    • ADDR : Tainted Network Address
    • CONF : Tainted Configuration Setting
    • ENV : Tainted Environment Variable
    • FNAME : Tainted Filename
    • SIZE : Tainted Allocation Size
    • WRITE : Tainted Write
  • UAC : Use After Close
  • UT
    • HOST : Untrusted Network Host
    • LIB : Untrusted Library Load
    • PORT : Untrusted Network Port
    • PROC : Untrusted Process Creation
  • WRITERO : Write to Read Only File
• JAVA : Java Warning Classes
  • ALLOC
    • LEAK
      • ANDROID : Android Leak (Java)
      • NOTCLOSED : Closeable Not Closed (Java)
      • NOTSTORED : Closeable Not Stored (Java)
  • ARITH
    • FPEQUAL : Floating Point Equality (Java)
    • OFLOW : Cast: int Computation to long (Java)
  • CAST
    • FTRUNC : Cast: Integer to Floating Point (Java)
  • CLASS
    • ACCESS
      • BYPASS : Reflection Bypasses Member Accessibility (Java)
      • MODIFY : Reflection Modifies Member Accessibility (Java)
    • ACIC : Ambiguous Call from Inner Class (Java)
    • BUB : Inefficient Box-Unbox (Java)
    • CAST : Risky Class Cast (Java)
      • ARRSTORE : Risky array store (Java)
      • USELESS : Useless Class Cast (Java)
    • CLONE
      • CCSM : Clone Call to Super is Missing (Java)
      • CNC : clone Non-cloneable (Java)
      • NF : clone not final (Java)
      • SCNC : clone Subclass of Non-clonable (Java)
    • ICL : Insecure Class Loader (Java)
    • ICSBS : Inner Class Should be Static (Java)
    • IOF
      • BAD : Inappropriate Instanceof (Java)
      • F : Instanceof Always False (Java)
      • T : Instanceof Always True (Java)
    • MCS : Missing Call to super (Java)
    • METH
      • NF : Method Should be final (Java)
    • OR
      • ISVALIDFRAGMENT : Missing isValidFragment Override (Java)
    • RI : Redundant Implements Clause (Java)
    • SER
      • DESER : Deserializable Class (Java)
      • DNS : Deserializing Non-Serializable Class (Java)
      • ENON : Nonserializable Field Element (Java)
      • FNON : Nonserializable Field (Java)
      • ND : Serialization Not Disabled (Java)
      • OCNON : Nonserializable Outer Class (Java)
      • UIDM : Missing Serial Version Field (Java)
      • UIDU : Unexpected Serial Version Field (Java)
    • STATICMOD : Static Field Assigned Non-Static (Java)
    • UI : Inefficient Instantiation (Java)
    • UIGC : Unnecessary Instantiation for GetClass (Java)
    • VIS
      • FIELD : Field Too Visible (Java)
      • METH
        • PRIV : Method Should be private (Java)
      • SFIELD : Static Field Too Visible (Java)
  • COMPARE
    • CTO
      • ASSYM : Asymmetric compareTo (Java)
      • NONCOMP : compareTo in Non-Comparable Class (Java)
      • NONOBJ : Non-Object compareTo Parameter (Java)
    • EMPTYSTR : Comparison to Empty String (Java)
    • EQ : Should Use equals() Instead of == (Java)
    • EQARRAY : equals on Array (Java)
    • EQUALS : Should Use == Instead of equals() (Java)
      • CN : Comparison to Class Names (Java)
  • CONCURRENCY
    • LOCK
      • DCL : Double-Checked Locking (Java)
      • ICS : Impossible Client Side Locking (Java)
      • ISTR : Synchronization on Interned String (Java)
      • SCTB : Synchronous Call to Thread Body (Java)
      • STATIC : Synchronization on static (Java)
      • USELESS : Useless Synchronization (Java)
    • STARVE
      • BLOCKING : Blocking in Critical Section (Java)
    • SYNC
      • MSS : Missing synchronized Statement (Java)
    • UG
      • FIELD : Unguarded Field (Java)
      • METH : Unguarded Method (Java)
      • PARAM : Unguarded Parameter (Java)
    • VOLATILE : Useless volatile Modifier (Java)
  • CRYPTO
    • BASE64 : Unsafe Base64 Encoding (Java)
    • CADRC : Cryptographic Algorithm with Risky Default Cipher (Java)
    • CARC : Cryptographic Algorithm with Weak Cipher (Java)
    • CAWH : Cryptographic Algorithm with Weak Hash (Java)
    • DEPRECATED : Deprecated Cryptography Provider (Java)
    • KEY : Insecure Key Derivation (Java)
    • MRCS : Missing Required Cryptographic Step (Java)
    • RA : Risky Cryptographic Algorithm (Java)
    • RCA : Risky Cipher Algorithm (Java)
    • RCF : Risky Cipher Field (Java)
    • RF : Risky Cryptographic Field (Java)
    • SALT : Inadequate Salt (Java)
    • VALUE : Weak Cryptographic Value (Java)
    • WHA : Weak Hash Algorithm (Java)
    • WHAF : Weak Hash Algorithm Field (Java)
    • WIV : Weak Initialization Vector Value (Java)
    • WIVF : Weak Initialization Vector Field (Java)
  • DEBUG
    • CALL : Debug Call (Java)
    • CEDF : Class Enables Debug Features (Java)
    • ID : Exception Information Disclosure (Java)
    • LOG : Debug Warning (Java)
    • MEDF : Method Enables Debug Features (Java)
  • DEEPNULL
    • DEREF : Null Pointer Dereference (deep) (Java)
    • EFIELD : Field Element may be null (deep) (Java)
    • FIELD : Field may be null (deep) (Java)
    • PARAM
      • ACTUAL : null Passed to Method (deep) (Java)
      • EACTUAL : Actual Parameter Element may be null (Java)
    • RET
      • EMETH : Return Value may Contain null Element (Java)
      • METH : Return Value may be null (Java)
    • UTEST : Useless null Test (Java)
      • FIELD : Useless null Test of Field (Java)
      • PARAM : Useless null Test of Parameter (Java)
      • RV : Useless null Test of Return Value (Java)
  • FUNCS
    • APE : Array Parameter Empty (Java)
    • EF : Explicit Finalize (Java)
    • INFREC : Potential Infinite Recursion (Java)
    • IRV : Ignored Return Value (Java)
      • PURE : Ignored Return Value for Pure Function (Java)
    • RED
      • INT : Redundant Call for Integral Argument (Java)
      • STR : Redundant Call for String Argument (Java)
  • HARDCODED
    • FNAME : Hardcoded Filename (Java)
    • IP : Hardcoded IP Address (Java)
    • KEY : Hardcoded Cryptographic Key (Java)
    • PASSWD : Hardcoded Password (Java)
      • FILE : Password in Property File (Java)
    • SEED : Hardcoded Random Seed (Java)
  • ID
    • BADOVERRIDE : Non-overriding Method Signature (Java)
    • CASE
      • METHOD : Method Names Differ Only in Case (Java)
    • SHADOW : Shadowed Identifier (Java)
    • STYLE : Naming Style Violation (Java)
  • IDEF
    • CTOEQ : compareTo/equals mismatch (Java)
    • CTONOEQ : compareTo without equals (Java)
    • EQUALS
      • NONOBJ : equals Parameter Should Be Object (Java)
    • EQUALSNOHC : Defines equals but not hashCode (Java)
    • HCNOEQUALS : Defines hashCode but not equals (Java)
    • NOEQUALS : Missing Equals Override (Java)
  • INSEC
    • CERT
      • RS : Certificate Added to Root Store (Java)
    • CVO : Insecure verify Override for Certificate (Java)
    • CVU : Use of Insecure verify for Certificate (Java)
    • DTP : Deprecated Transfer Protocol (Java)
    • EAR : Execution After Redirect (Java)
    • HIC : Hostname in Condition (Java)
    • HTTP
      • DTU : Direct Thread Usage in Http Servlet (Java)
    • HVO : Insecure verifier Override for Hostname (Java)
    • HVU : Use of Insecure verify for Hostname (Java)
    • LDAP
      • ANON : Anonymous LDAP Authentication (Java)
      • DA : LDAP Authentication Disabled (Java)
      • POISON : Potential LDAP Poisoning (Java)
    • MAA : Missing Authentication Annotation (Java)
    • MDSS : Method Disables Security Setting (Java)
    • SAC : Security Annotation Conflict (Java)
    • SF : Insecure Socket Factory (Java)
    • SS : Use of Same Seed (Java)
    • USET : Unsafe Session Expiration Time (Java)
  • IO
    • HWID : Use of Hardware ID (Java)
    • INJ
      • ANDROID
        • MESSAGE : Android Message Injection (Java)
        • URL : Android URL Injection (Java)
      • CODE : Code Injection (Java)
      • COMMAND : Command Injection (Java)
      • DENIAL : DOS Injection (Java)
      • DLL : DLL Injection (Java)
      • FMT : Format String Injection (Java)
      • FRAGMENT : Fragment Injection (Java)
      • SQL : SQL Injection (Java)
      • XSS : Cross Site Scripting (Java)
        • EMWP : Cross Site Scripting In Error Message Web Page (Java)
    • PERM : Permissive File Mode (Java)
      • ACCESS : Accessing File in Permissive Mode (Java)
    • TAINT
      • ADDR : Tainted Network Address (Java)
      • BUNDLE : Tainted Bundle (Java)
      • CONTROL : Tainted Control (Java)
      • DEVICE : Tainted Hardware Device Property (Java)
      • EVAL : Tainted Expression Evaluation (Java)
      • HTTP : Tainted HTTP Response (Java)
        • OR : Open Redirect (Java)
      • IC
        • FRAGMENT : Ineffective Cleansing of Fragment Taint (Java)
      • LDAP
        • ATTR : Tainted LDAP Attribute (Java)
        • FILTER : Tainted LDAP Filter (Java)
      • LOG : Tainted Log (Java)
      • MESSAGE : Tainted Message (Java)
      • PATH : Tainted Path (Java)
      • REFLECTION : Reflection Injection (Java)
      • REGEX : Tainted Regular Expression (Java)
      • RESOURCE : Tainted Resource (Java)
      • SESSION : Tainted Session (Java)
      • SIZE : Tainted Allocation Size (Java)
      • TRUSTED : Tainted @Trusted Value (Java)
      • URL : Tainted URL (Java)
      • VULN : Tainted Data in Vulnerable Method (Java)
      • XAML : Tainted XAML (Java)
      • XML : Tainted XML (Java)
      • XPATH : Tainted Xpath (Java)
    • UT
      • HOST : Untrusted Network Host (Java)
  • JS
    • FAFU : JavaScript File Access from File URLs (Java)
    • JSE : JavaScript Enabled (Java)
    • ME : Missing JavaScript Execution (Java)
    • MEP : Missing JavaScript Entry Point (Java)
    • RI : Risky JavaScript Interface (Java)
    • UAFU : Universal JavaScript Access to File URLs (Java)
  • LIB
    • HTTP
      • COOKIE : Insecure Cookie (Java)
    • RAND
      • FUNC : Insecure Random Number Generator (Java)
      • LEGACY
        • GEN : Legacy Random Generator (Java)
      • NEW : Single-use Random Number Generator (Java)
    • XML
      • INSEC_XSLT : Insecure XSLT Execution (Java)
      • XXE : Possible XML External Entity Reference (Java)
  • MATH
    • ABSRAND : Abs on random (Java)
    • APPROX
      • E : Approximate e Constant (Java)
      • PI : Approximate pi Constant (Java)
  • MISC
    • SD
      • CACHE : Sensitive Data Cached (Java)
      • EXT : Sensitive Data Written to External Storage (Java)
      • FILE : Sensitive Data Written to Local File (Java)
  • NULL
    • DEREF : Null Pointer Dereference (Java)
    • PARAM
      • ACTUAL : Null Parameter Dereference (Java)
      • LAMBDA : Lambda Parameter may be null (Java)
    • RET
      • ARRAY : Return null Array (Java)
      • BOOL : Return null Boolean (Java)
      • NONNULL : Method Should Not Return null (Java)
      • OPT : Return null Optional (Java)
      • UNCHECKED : Call Might Return Null (Java)
  • REDUNDANT
    • EQF : Impossible reference comparison (Java)
      • TYPE : == Always Fails Because Types Always Different (Java)
    • EQUALSF : equals Always Fails (Java)
  • STRUCT
    • ARCHIVE
      • EJF : Empty jar File Archived (Java)
      • EZF : Empty zip File Archived (Java)
    • BW
      • AND : Bitwise AND on Boolean (Java)
      • ANDC : Bitwise AND on Boolean Constant (Java)
      • ANDI : Inefficient Bitwise AND (Java)
      • OR : Bitwise OR on Boolean (Java)
      • ORC : Bitwise OR on Boolean Constant (Java)
      • ORI : Inefficient Bitwise OR (Java)
    • CONDASSIG : Assignment in Conditional (Java)
    • DUPD : Unchecked Parameter Dereference (deep) (Java)
    • EBS : Empty Branch Statement (Java)
    • EXCP
      • BROAD : Broad Throws Clause (Java)
      • EEH : Empty Exception Handler (Java)
      • GEH : Generic Exception Handler (Java)
      • INAPP : Inappropriate Exception Handler (Java)
    • RC : Redundant Condition (Java)
    • SE
      • ASSERT : Assertion Contains Side Effects (Java)
    • UA : Useless Assignment (Java)
      • DEFAULT : Useless Assignment to Default (Java)
    • UC
      • INSTR : Unreachable Instruction (Java)
    • UNFLD : Unnecessary Field (Java)
    • UPD : Unchecked Parameter Dereference (Java)
    • UPED : Unchecked Parameter Element Dereference (deep) (Java)
    • URFIELD : Field Never Read (Java)
    • UUCLASS : Unused Class (Java)
    • UUFIELD : Unused Field (Java)
    • UUMETH : Unused Method (Java)
    • UUOBJ : Unused Object (Java)
    • UUVAL
      • ACTUAL : Unused Value: Actual Parameter (Java)
      • PARAM : Unused Value: Write to Parameter (Java)
      • VAR : Unused Value: Variable (Java)
    • UWFIELD : Field Never Written (Java)
  • TYPE
    • ARRAYTOSTRING : toString on Array (Java)
    • MCF : Mutable Constant Field (Java)
    • ME : Mutable Enumeration (Java)
    • MPSFA : Mutable Public Static Final Array (Java)
• JS : JavaScript Warning Classes
  • LAYOUT
    • ABN : Array Bracket Newline (ESLint)
    • ABS : Array Bracket Spacing (ESLint)
    • AEN : Array Element Newline (ESLint)
    • AP : Arrow Parens (ESLint)
    • AS : Arrow Spacing (ESLint)
    • BLKSP : Block Spacing (ESLint)
    • BRSTYLE : Brace Style (ESLint)
    • CD : Comma Dangle (ESLint)
    • COMSP : Comma Spacing (ESLint)
    • COMSTYLE : Comma Style (ESLint)
    • CPS : Computed Property Spacing (ESLint)
    • DL : Dot Location (ESLint)
    • EL : Eol Last (ESLint)
    • FCAN : Function Call Argument Newline (ESLint)
    • FCS : Func Call Spacing (ESLint)
    • FPN : Function Paren Newline (ESLint)
    • GSS : Generator Star Spacing (ESLint)
    • IAL : Implicit Arrow Linebreak (ESLint)
    • IL : Indent Legacy (ESLint)
    • INDENT : Indent (ESLint)
    • JQ : Jsx Quotes (ESLint)
    • KEYSP : Key Spacing (ESLint)
    • KWDSP : Keyword Spacing (ESLint)
    • LAC : Lines Around Comment (ESLint)
    • LAD : Lines Around Directive (ESLint)
    • LBCM : Lines Between Class Members (ESLint)
    • LCP : Line Comment Position (ESLint)
    • LS : Linebreak Style (ESLint)
    • ML : Max Len (ESLint)
    • MSPL : Max Statements Per Line (ESLint)
    • MT : Multiline Ternary (ESLint)
    • NAV : Newline After Var (ESLint)
    • NBR : Newline Before Return (ESLint)
    • NEP : No Extra Parens (ESLint)
    • NMEL : No Multiple Empty Lines (ESLint)
    • NMS : No Multi Spaces (ESLint)
    • NMSAT : No Mixed Spaces and Tabs (ESLint)
    • NP : New Parens (ESLint)
    • NPCC : Newline Per Chained Call (ESLint)
    • NSBP : Nonblock Statement Body Position (ESLint)
    • NSF : No Spaced Func (ESLint)
    • NT : No Tabs (ESLint)
    • NTS : No Trailing Spaces (ESLint)
    • NWBP : No Whitespace Before Property (ESLint)
    • OCN : Object Curly Newline (ESLint)
    • OCS : Object Curly Spacing (ESLint)
    • OL : Operator Linebreak (ESLint)
    • OPN : Object Property Newline (ESLint)
    • PB : Padded Blocks (ESLint)
    • PLBS : Padding Line Between Statements (ESLint)
    • QUOTES : Quotes (ESLint)
    • RSS : Rest Spread Spacing (ESLint)
    • SBB : Space Before Blocks (ESLint)
    • SBFP : Space Before Function Paren (ESLint)
    • SCS : Switch Colon Spacing (ESLint)
    • SEMI : Semi (ESLint)
    • SIO : Space Infix Ops (ESLint)
    • SIP : Space in Parens (ESLint)
    • SSP : Semi Spacing (ESLint)
    • SSTYLE : Semi Style (ESLint)
    • SUO : Space Unary Ops (ESLint)
    • TCS : Template Curly Spacing (ESLint)
    • TTS : Template Tag Spacing (ESLint)
    • UB : Unicode Bom (ESLint)
    • WI : Wrap Iife (ESLint)
    • WR : Wrap Regex (ESLint)
    • YSS : Yield Star Spacing (ESLint)
  • PROBLEM
    • ACR : Array Callback Return (ESLint)
    • CS : Constructor Super (ESLint)
    • FD : For Direction (ESLint)
    • GR : Getter Return (ESLint)
    • NAIL : No Await in Loop (ESLint)
    • NAPE : No Async Promise Executor (ESLint)
    • NBC : No Buffer Constructor (ESLint)
    • NCBE : No Constant Binary Expression (ESLint)
    • NCC : No Constant Condition (ESLint)
    • NCLSA : No Class Assign (ESLint)
    • NCNZ : No Compare Neg Zero (ESLint)
    • NCONDA : No Cond Assign (ESLint)
    • NCONSR : No Constructor Return (ESLint)
    • NCONSTA : No Const Assign (ESLint)
    • NCTLR : No Control Regex (ESLint)
    • ND : No Debugger (ESLint)
    • NDA : No Dupe Args (ESLint)
    • NDC : No Duplicate Case (ESLint)
    • NDCM : No Dupe Class Members (ESLint)
    • NDEI : No Dupe Else If (ESLint)
    • NDI : No Duplicate Imports (ESLint)
    • NDK : No Dupe Keys (ESLint)
    • NEA : No Ex Assign (ESLint)
    • NECC : No Empty Character Class (ESLint)
    • NEP : No Empty Pattern (ESLint)
    • NF : No Fallthrough (ESLint)
    • NFA : No Func Assign (ESLint)
    • NIA : No Import Assign (ESLint)
    • NID : No Inner Declarations (ESLint)
    • NIR : No Invalid Regexp (ESLint)
    • NIW : No Irregular Whitespace (ESLint)
    • NLOP : No Loss of Precision (ESLint)
    • NMCC : No Misleading Character Class (ESLint)
    • NNIL : No Negated in Lhs (ESLint)
    • NNNN : No New Native Nonconstructor (ESLint)
    • NNS : No New Symbol (ESLint)
    • NOC : No Obj Calls (ESLint)
    • NPB : No Prototype Builtins (ESLint)
    • NPER : No Promise Executor Return (ESLint)
    • NSC : No Self Compare (ESLint)
    • NSELFA : No Self Assign (ESLint)
    • NSPRSA : No Sparse Arrays (ESLint)
    • NSR : No Setter Return (ESLint)
    • NTBS : No This Before Super (ESLint)
    • NTCIS : No Template Curly in String (ESLint)
    • NUB : No Useless Backreference (ESLint)
    • NUBD : No Use Before Define (ESLint)
    • NUF : No Unsafe Finally (ESLint)
    • NUL : No Unreachable Loop (ESLint)
    • NULC : No Unmodified Loop Condition (ESLint)
    • NUM : No Unexpected Multiline (ESLint)
    • NUN : No Unsafe Negation (ESLint)
    • NUNDEF : No Undef (ESLint)
    • NUOC : No Unsafe Optional Chaining (ESLint)
    • NUPCM : No Unused Private Class Members (ESLint)
    • NUREACH : No Unreachable (ESLint)
    • NUV : No Unused Vars (ESLint)
    • RAU : Require Atomic Updates (ESLint)
    • UI : Use Isnan (ESLint)
    • VT : Valid Typeof (ESLint)
  • SUGGESTION
    • ABS : Arrow Body Style (ESLint)
    • AP : Accessor Pairs (ESLint)
    • BSV : Block Scoped Var (ESLint)
    • CALLRET : Callback Return (ESLint)
    • CAMCASE : Camelcase (ESLint)
    • CC : Capitalized Comments (ESLint)
    • CMPLX : Complexity (ESLint)
    • CMUT : Class Methods Use This (ESLint)
    • CONRET : Consistent Return (ESLint)
    • CT : Consistent This (ESLint)
    • CURLY : Curly (ESLint)
    • DC : Default Case (ESLint)
    • DCL : Default Case Last (ESLint)
    • DN : Dot Notation (ESLint)
    • DPL : Default Param Last (ESLint)
    • EQEQEQ : Equal-Equal-Equal (ESLint)
    • FN : Func Names (ESLint)
    • FNM : Func Name Matching (ESLint)
    • FS : Func Style (ESLint)
    • GAP : Grouped Accessor Pairs (ESLint)
    • GFI : Guard for in (ESLint)
    • GR : Global Require (ESLint)
    • HCE : Handle Callback Err (ESLint)
    • IB : Id Blacklist (ESLint)
    • IDDENY : Id Denylist (ESLint)
    • IL : Id Length (ESLint)
    • IM : Id Match (ESLint)
    • INITDCL : Init Declarations (ESLint)
    • LAO : Logical Assignment Operators (ESLint)
    • MCPF : Max Classes Per File (ESLint)
    • MCS : Multiline Comment Style (ESLint)
    • MD : Max Depth (ESLint)
    • ML : Max Lines (ESLint)
    • MLPF : Max Lines Per Function (ESLint)
    • MNC : Max Nested Callbacks (ESLint)
    • MP : Max Params (ESLint)
    • MS : Max Statements (ESLint)
    • NA : No Alert (ESLint)
    • NAC : No Array Constructor (ESLint)
    • NB : No Bitwise (ESLint)
    • NCA : No Confusing Arrow (ESLint)
    • NCALLER : No Caller (ESLint)
    • NCD : No Case Declarations (ESLint)
    • NCNSL : No Console (ESLint)
    • NCONT : No Continue (ESLint)
    • NCS : No Catch Shadow (ESLint)
    • NDR : No Div Regex (ESLint)
    • NDV : No Delete Var (ESLint)
    • NEB : No Extra Bind (ESLint)
    • NEBC : No Extra Boolean Cast (ESLint)
    • NEF : No Empty Function (ESLint)
    • NEL : No Extra Label (ESLint)
    • NEMPTY : No Empty (ESLint)
    • NEQN : No Eq Null (ESLint)
    • NER : No Else Return (ESLint)
    • NES : No Extra Semi (ESLint)
    • NESB : No Empty Static Block (ESLint)
    • NEVAL : No Eval (ESLint)
    • NEWCAP : New Cap (ESLint)
    • NEXTNAT : No Extend Native (ESLint)
    • NFD : No Floating Decimal (ESLint)
    • NGA : No Global Assign (ESLint)
    • NI : No Iterator (ESLint)
    • NICOER : No Implicit Coercion (ESLint)
    • NICOM : No Inline Comments (ESLint)
    • NIE : No Implied Eval (ESLint)
    • NIG : No Implicit Globals (ESLint)
    • NIT : No Invalid This (ESLint)
    • NL : No Labels (ESLint)
    • NLB : No Lone Blocks (ESLint)
    • NLF : No Loop Func (ESLint)
    • NLI : No Lonely If (ESLint)
    • NLV : No Label Var (ESLint)
    • NMA : No Multi Assign (ESLint)
    • NMN : No Magic Numbers (ESLint)
    • NMO : No Mixed Operators (ESLint)
    • NMR : No Mixed Requires (ESLint)
    • NMS : No Multi Str (ESLint)
    • NN : No New (ESLint)
    • NNATRE : No Native Reassign (ESLint)
    • NNC : No Negated Condition (ESLint)
    • NNDE : No Nonoctal Decimal Escape (ESLint)
    • NNEWREQ : No New Require (ESLint)
    • NNF : No New Func (ESLint)
    • NNO : No New Object (ESLint)
    • NNT : No Nested Ternary (ESLint)
    • NNW : No New Wrappers (ESLint)
    • NO : No Octal (ESLint)
    • NOC : No Object Constructor (ESLint)
    • NOE : No Octal Escape (ESLint)
    • NPC : No Path Concat (ESLint)
    • NPENV : No Process Env (ESLint)
    • NPEXIT : No Process Exit (ESLint)
    • NPP : No Plusplus (ESLint)
    • NPR : No Param Reassign (ESLint)
    • NPROTO : No Proto (ESLint)
    • NR : No Redeclare (ESLint)
    • NRE : No Restricted Exports (ESLint)
    • NREGEXSP : No Regex Spaces (ESLint)
    • NRETA : No Return Assign (ESLint)
    • NRETAW : No Return Await (ESLint)
    • NRG : No Restricted Globals (ESLint)
    • NRI : No Restricted Imports (ESLint)
    • NRM : No Restricted Modules (ESLint)
    • NRP : No Restricted Properties (ESLint)
    • NRSNTX : No Restricted Syntax (ESLint)
    • NSEQS : No Sequences (ESLint)
    • NSHDW : No Shadow (ESLint)
    • NSRN : No Shadow Restricted Names (ESLint)
    • NSU : No Script Url (ESLint)
    • NSYNC : No Sync (ESLint)
    • NT : No Ternary (ESLint)
    • NTL : No Throw Literal (ESLint)
    • NU : No Undefined (ESLint)
    • NUCALL : No Useless Call (ESLint)
    • NUCAT : No Useless Concat (ESLint)
    • NUCK : No Useless Computed Key (ESLint)
    • NUCONS : No Useless Constructor (ESLint)
    • NUCTCH : No Useless Catch (ESLint)
    • NUD : No Underscore Dangle (ESLint)
    • NUESC : No Useless Escape (ESLint)
    • NUEXP : No Unused Expressions (ESLint)
    • NUI : No Undef Init (ESLint)
    • NUL : No Unused Labels (ESLint)
    • NUREN : No Useless Rename (ESLint)
    • NURET : No Useless Return (ESLint)
    • NUT : No Unneeded Ternary (ESLint)
    • NVAR : No Var (ESLint)
    • NVOID : No Void (ESLint)
    • NW : No With (ESLint)
    • NWC : No Warning Comments (ESLint)
    • OA : Operator Assignment (ESLint)
    • OS : Object Shorthand (ESLint)
    • OV : One Var (ESLint)
    • OVDPL : One Var Declaration Per Line (ESLint)
    • PAC : Prefer Arrow Callback (ESLint)
    • PC : Prefer Const (ESLint)
    • PD : Prefer Destructuring (ESLint)
    • PEO : Prefer Exponentiation Operator (ESLint)
    • PNCG : Prefer Named Capture Group (ESLint)
    • PNL : Prefer Numeric Literals (ESLint)
    • POHO : Prefer Object Has Own (ESLint)
    • POS : Prefer Object Spread (ESLint)
    • PPRE : Prefer Promise Reject Errors (ESLint)
    • PR : Prefer Reflect (ESLint)
    • PRL : Prefer Regex Literals (ESLint)
    • PRP : Prefer Rest Params (ESLint)
    • PS : Prefer Spread (ESLint)
    • PT : Prefer Template (ESLint)
    • QP : Quote Props (ESLint)
    • RA : Require Await (ESLint)
    • RADIX : Radix (ESLint)
    • RJ : Require Jsdoc (ESLint)
    • RUR : Require Unicode Regexp (ESLint)
    • RY : Require Yield (ESLint)
    • SC : Spaced Comment (ESLint)
    • SD : Symbol Description (ESLint)
    • SI : Sort Imports (ESLint)
    • SK : Sort Keys (ESLint)
    • STRICT : Strict (ESLint)
    • SV : Sort Vars (ESLint)
    • VJ : Valid Jsdoc (ESLint)
    • VOT : Vars on Top (ESLint)
    • YODA : Yoda (ESLint)
• KOTLIN : Kotlin Warning Classes
  • BUGS
    • ARE : Avoid Referential Equality (detekt)
    • CNTNNT : Cast Nullable to Non Nullable Type (detekt)
    • CTNT : Cast to Nullable Type (detekt)
    • DDCT : Dont Downcast Collection Types (detekt)
    • DEPRECATION : Deprecation (detekt)
    • DMFC : Double Mutability for Collection (detekt)
    • EARTOF : Equals Always Returns True or False (detekt)
    • ECIOEW : Else Case Instead of Exhaustive When (detekt)
    • EGCC : Explicit Garbage Collection Call (detekt)
    • EOM : Exit Outside Main (detekt)
    • EWHCE : Equals With Hash Code Exist (detekt)
    • HPT : Has Platform Type (detekt)
    • IDL : Implicit Default Locale (detekt)
    • IHNCNM : Iterator Has Next Calls Next Method (detekt)
    • INTNSEE : Iterator Not Throwing No Such Element Exception (detekt)
    • IR : Invalid Range (detekt)
    • IRV : Ignored Return Value (detekt)
    • IURT : Implicit Unit Return Type (detekt)
    • LU : Lateinit Usage (detekt)
    • MGWNNAO : Map Get With Not Null Assertion Operator (detekt)
    • MPD : Missing Package Declaration (detekt)
    • NCOMP : Null Check on Mutable Property (detekt)
    • NTSC : Nullable to String Call (detekt)
    • PUBD : Property Used Before Declaration (detekt)
    • UCB : Unreachable Catch Block (detekt)
    • UCODE : Unreachable Code (detekt)
    • UCONT : Unsafe Call on Nullable Type (detekt)
    • UJSIL : Unconditional Jump Statement in Loop (detekt)
    • UNNC : Unnecessary Not Null Check (detekt)
    • UNNO : Unnecessary Not Null Operator (detekt)
    • UPE : Useless Postfix Expression (detekt)
    • USC : Unnecessary Safe Call (detekt)
    • USCAST : Unsafe Cast (detekt)
    • UUO : Unused Unary Operator (detekt)
    • WETP : Wrong Equals Type Parameter (detekt)
  • COMMENTS
    • AOWFL : Absent or Wrong File License (detekt)
    • COPF : Comment Over Private Function (detekt)
    • COPP : Comment Over Private Property (detekt)
    • DBT : Deprecated Block Tag (detekt)
    • EOSF : End of Sentence Format (detekt)
    • KDRNPP : KDoc References Non Public Property (detekt)
    • OD : Outdated Documentation (detekt)
    • UPC : Undocumented Public Class (detekt)
    • UPF : Undocumented Public Function (detekt)
    • UPP : Undocumented Public Property (detekt)
  • COMPLEXITY
    • CC : Complex Condition (detekt)
    • CI : Complex Interface (detekt)
    • COGCM : Cognitive Complex Method (detekt)
    • CYCCM : Cyclomatic Complex Method (detekt)
    • LC : Large Class (detekt)
    • LE : Labeled Expression (detekt)
    • LM : Long Method (detekt)
    • LPL : Long Parameter List (detekt)
    • MO : Method Overloading (detekt)
    • NA : Named Arguments (detekt)
    • NBD : Nested Block Depth (detekt)
    • NSF : Nested Scope Functions (detekt)
    • RSCCWR : Replace Safe Call Chain With Run (detekt)
    • SLD : String Literal Duplication (detekt)
    • TMF : Too Many Functions (detekt)
  • COROUTINES
    • GCU : Global Coroutine Usage (detekt)
    • ID : Inject Dispatcher (detekt)
    • RSM : Redundant Suspend Modifier (detekt)
    • SFSC : Suspend Fun Swallowed Cancellation (detekt)
    • SFWCSR : Suspend Fun With Coroutine Scope Receiver (detekt)
    • SFWFRT : Suspend Fun With Flow Return Type (detekt)
    • SIOD : Sleep Instead of Delay (detekt)
  • EMPTY-BLOCKS
    • ECLSB : Empty Class Block (detekt)
    • ECTCHB : Empty Catch Block (detekt)
    • EDC : Empty Default Constructor (detekt)
    • EDWB : Empty Do While Block (detekt)
    • EEB : Empty Else Block (detekt)
    • EFINB : Empty Finally Block (detekt)
    • EFORB : Empty for Block (detekt)
    • EFUNB : Empty Function Block (detekt)
    • EIFB : Empty If Block (detekt)
    • EINITB : Empty Init Block (detekt)
    • EKF : Empty Kt File (detekt)
    • ESC : Empty Secondary Constructor (detekt)
    • ETB : Empty Try Block (detekt)
    • EWHENB : Empty When Block (detekt)
    • EWHILEB : Empty While Block (detekt)
  • EXCEPTIONS
    • ERIUL : Exception Raised in Unexpected Location (detekt)
    • IOCFE : Instance of Check for Exception (detekt)
    • NID : Not Implemented Declaration (detekt)
    • OET : Object Extends Throwable (detekt)
    • PST : Print Stack Trace (detekt)
    • RCE : Rethrow Caught Exception (detekt)
    • RFF : Return From Finally (detekt)
    • SE : Swallowed Exception (detekt)
    • TEFF : Throwing Exception From Finally (detekt)
    • TEIM : Throwing Exception in Main (detekt)
    • TEWMOC : Throwing Exceptions Without Message or Cause (detekt)
    • TGEC : Too Generic Exception Caught (detekt)
    • TGET : Too Generic Exception Thrown (detekt)
    • TNIOSE : Throwing New Instance of Same Exception (detekt)
  • NAMING
    • BPN : Boolean Property Naming (detekt)
    • CN : Class Naming (detekt)
    • CPN : Constructor Parameter Naming (detekt)
    • EN : Enum Naming (detekt)
    • FCN : Forbidden Class Name (detekt)
    • FMAXL : Function Max Length (detekt)
    • FMINL : Function Min Length (detekt)
    • FN : Function Naming (detekt)
    • FPN : Function Parameter Naming (detekt)
    • IPD : Invalid Package Declaration (detekt)
    • LPN : Lambda Parameter Naming (detekt)
    • MDN : Matching Declaration Name (detekt)
    • MNECN : Member Name Equals Class Name (detekt)
    • NBPPWI : Non Boolean Property Prefixed With Is (detekt)
    • NNS : No Name Shadowing (detekt)
    • OPN : Object Property Naming (detekt)
    • PN : Package Naming (detekt)
    • TLPN : Top Level Property Naming (detekt)
    • VMAXL : Variable Max Length (detekt)
    • VMINL : Variable Min Length (detekt)
    • VN : Variable Naming (detekt)
  • PERFORMANCE
    • AP : Array Primitive (detekt)
    • CBS : Could Be Sequence (detekt)
    • FEOR : For Each on Range (detekt)
    • SO : Spread Operator (detekt)
    • UPOBE : Unnecessary Part of Binary Expression (detekt)
    • UTI : Unnecessary Temporary Instantiation (detekt)
  • STYLE
    • ACBA : Also Could Be Apply (detekt)
    • BOIS : Braces on If Statements (detekt)
    • BOWS : Braces on When Statements (detekt)
    • CBNN : Can Be Non Nullable (detekt)
    • CCW : Cascading Call Wrapping (detekt)
    • CIS : Collapsible If Statements (detekt)
    • CO : Class Ordering (detekt)
    • DCCF : Data Class Contains Functions (detekt)
    • DCSBI : Data Class Should Be Immutable (detekt)
    • DDWTME : Destructuring Declaration With Too Many Entries (detekt)
    • DNL : Double Negative Lambda (detekt)
    • EBS : Expression Body Syntax (detekt)
    • ECEAM : Explicit Collection Element Access Method (detekt)
    • EILP : Explicit It Lambda Parameter (detekt)
    • ENC : Equals Null Call (detekt)
    • EOSL : Equals on Signature Line (detekt)
    • FA : Forbidden Annotation (detekt)
    • FC : Forbidden Comment (detekt)
    • FI : Forbidden Import (detekt)
    • FMC : Forbidden Method Call (detekt)
    • FORC : Function Only Returning Constant (detekt)
    • FS : Forbidden Suppress (detekt)
    • FV : Forbidden Void (detekt)
    • LWTMJS : Loop With Too Many Jump Statements (detekt)
    • MBC : May Be Const (detekt)
    • MBL : Mandatory Braces Loops (detekt)
    • MCCOSL : Max Chained Calls on Same Line (detekt)
    • MLIP : Multiline Lambda It Parameter (detekt)
    • MLL : Max Line Length (detekt)
    • MN : Magic Number (detekt)
    • MO : Modifier Order (detekt)
    • MRSI : Multiline Raw String Indentation (detekt)
    • NBC : Nullable Boolean Check (detekt)
    • NCV : Nested Classes Visibility (detekt)
    • NLAEOF : New Line at End of File (detekt)
    • NT : No Tabs (detekt)
    • OAK : Optional Abstract Keyword (detekt)
    • OLTL : Object Literal to Lambda (detekt)
    • OU : Optional Unit (detekt)
    • PMIFC : Protected Member in Final Class (detekt)
    • PTOPS : Prefer to Over Pair Syntax (detekt)
    • RC : Return Count (detekt)
    • RET : Redundant Explicit Type (detekt)
    • RHOMU : Redundant Higher Order Map Usage (detekt)
    • RVMR : Redundant Visibility Modifier Rule (detekt)
    • SBPAI : Spacing Between Package and Imports (detekt)
    • SC : Safe Cast (detekt)
    • SSBRS : String Should Be Raw String (detekt)
    • SVUIDISC : Serial Version UIDIn Serializable Class (detekt)
    • TC : Throws Count (detekt)
    • TMRS : Trim Multiline Raw String (detekt)
    • TW : Trailing Whitespace (detekt)
    • UA : Unnecessary Apply (detekt)
    • UAC : Unnecessary Abstract Class (detekt)
    • UALIA : Use Array Literals in Annotations (detekt)
    • UAONIOF : Use Any or None Instead of Find (detekt)
    • UAUST : Unnecessary Annotation Use Site Target (detekt)
    • UB : Unnecessary Backticks (detekt)
    • UBATL : Unnecessary Braces Around Trailing Lambda (detekt)
    • UCNN : Use Check Not Null (detekt)
    • UCOE : Use Check or Error (detekt)
    • UCONN : Useless Call on Not Null (detekt)
    • UCWPC : Utility Class With Public Constructor (detekt)
    • UDC : Use Data Class (detekt)
    • UEC : Use Empty Counterpart (detekt)
    • UF : Unnecessary Filter (detekt)
    • UIC : Unnecessary Inner Class (detekt)
    • UIEOIB : Use If Empty or If Blank (detekt)
    • UIIOW : Use If Instead of When (detekt)
    • UINH : Unnecessary Inheritance (detekt)
    • UINL : Underscores in Numeric Literals (detekt)
    • UINOE : Use Is Null or Empty (detekt)
    • UIORT : Until Instead of Range to (detekt)
    • UNL : Unnecessary Let (detekt)
    • UNP : Unnecessary Parentheses (detekt)
    • UOE : Use or Empty (detekt)
    • UPC : Unused Private Class (detekt)
    • UPM : Unused Private Member (detekt)
    • UPP : Unused Private Property (detekt)
    • UR : Use Require (detekt)
    • URNN : Use Require Not Null (detekt)
    • USELET : Use Let (detekt)
    • USOIOFMS : Use Sum of Instead of Flat Map Size (detekt)
    • UUIMP : Unused Imports (detekt)
    • UUPARAM : Unused Parameter (detekt)
    • VCBV : Var Could Be Val (detekt)
    • WI : Wildcard Import (detekt)
• LANG : Language-Use Problems
  • ARITH
    • BIGSHIFT : Shift Amount Exceeds Bit Width
    • DIVZERO : Division By Zero
    • FDIVZERO : Float Division By Zero
    • FMULOFLOW : Float Multiplication Overflow
    • FPEQUAL : Floating Point Equality
    • NEGSHIFT : Negative Shift Amount
  • ASM : Inline Assembly Code
    • MIXED : Mixed Assembly and Code
    • PRAGMA : Assembly Pragma
  • CAST
    • ARRAY
      • POINTER : Array to Pointer Decay
      • TEMP : Array to Pointer Conversion on Temporary Object
    • COERCE : Coercion Alters Value
    • CSTYLE : C-style Cast
    • FN : Dangerous Function Cast
    • NULL
      • INT : NULL Used as Integer
    • OBJSLICE : Object Slicing
    • PC
      • AO : Cast: Non-integer Arithmetic Type/Object Pointer
      • AV : Cast: Arithmetic Type/Void Pointer
      • CONST2PTR : Coercion: Integer Constant to Pointer
      • CRCQ : Cast Removes const Qualifier
      • CRVQ : Cast Removes volatile Qualifier
      • DATA2FN : Conversion to Function Pointer
      • FLOAT : Float Pointer Conversion
      • FN2DATA : Conversion from Function Pointer
      • INC : Conversion: Pointer to Incomplete
      • INT : Conversion: Pointer/Integer
      • OBJ : Cast: Object Pointers
      • PV : Conversion: Void Pointer to Object Pointer
      • VBASE : Cast: Virtual Base to Derived
    • RIP : Risky Integer Promotion
    • VALUE : Cast Alters Value
    • VARARG : Varargs Function Cast
  • COMM
    • CODE : Commented-out Code
    • CPP : C++ Comment in C
    • NEST
      • CPPSTYLE : // in Comment
      • CSTYLE : /* in Comment
    • SPLICE : Line Splicing in Comment
    • TODO : Comment Suggests Code Unfinished
  • ERRCODE
    • ITEST : Inappropriate Test of Error Code
    • NOTEST : Missing Test of Error Code
    • NZ : Non-zero Error Code
  • EXT
    • GNU : GNU Extension
    • MS : Microsoft Extension
    • TYPEOF : GNU Typeof
  • FUNCS
    • AP : Array Parameter
    • APM : Array Parameter Mismatch
    • ASSERTS : Not Enough Assertions
    • COPINC : Copy Operation Parameter Is Not const
    • DEFAULT
      • OVERRIDE : Method Default Value Mismatch
    • ICS : Implicit Constructor Shadowing
    • IRV : Ignored Return Value
    • MODP : Modified Parameter
    • MRV : Missing Return Value
    • NORETURN : Use of Noreturn
    • PROT : Incomplete Function Prototype
    • RECURSION : Recursion
    • SAP : Static Array Parameter
    • TMFP : Too Many Parameters
    • TOOLONG : Function Too Long
  • ID
    • AMBIG : Typographically Ambiguous Identifiers
    • ND
      • EXT : Non-distinct Identifiers: External Names
      • MM : Non-distinct Identifiers: Macro/Macro
      • MO : Non-distinct Identifiers: Macro/Other
      • NEST : Non-distinct Identifiers: Nested Scope
      • SS : Non-distinct Identifiers: Same Scope
    • NU
      • EXT : Non-unique Identifiers: External Name
      • INT : Non-unique Identifiers: Internal Name
      • LIBFN : Library Function Override
      • MK : Macro Name is C Keyword
      • TAG : Non-unique Identifiers: Tag
      • TYPE : Non-unique Identifiers: Typedef
    • STYLE : Naming Style Violation
  • LAMBDA
    • CAPTURE : Implicit Lambda Capture
    • MPL : Lambda Has No Parameter List
    • MRT : Lambda Has No Return Type
  • MEM
    • BO : Buffer Overrun
    • BU : Buffer Underrun
    • NPD : Null Pointer Dereference
    • TBA : Tainted Buffer Access
    • TO : Type Overrun
    • TU : Type Underrun
    • UVAR : Uninitialized Variable
  • METRIC
    • VG_P : High Cyclomatic Complexity (Procedure)
  • OPS
    • OVERLOADS : Confusing Operator Overload
  • PREPROC
    • ARROW : Macro Uses -> Operator
    • BRACES : Macro Uses [] Operator
    • CBI : Code Before #include
    • COND : Conditional Compilation
    • DEFINE : Use of #define
    • DEFINFN : Macro Defined in Function Body
    • ELIF : Use of #elif
    • ELIFDEF : Use of #elifdef
    • ELIFNDEF : Use of #elifndef
    • ELSE : Use of #else
    • ENDIF : Use of #endif
    • ERROR : Use of #error
    • FUNCMACRO : Function-Like Macro
    • HASH : Macro Uses # Operator
    • ICONST : Inappropriate Argument to Integer Constant Macro
    • IF : Use of #if
    • IFDEF : Use of #ifdef
    • IFNDEF : Use of #ifndef
    • IMPORT : Use of #import
    • INCL
      • FNAME : Dangerous Include File Name
      • IIFS : Inappropriate Include File Specification
      • MF : Malformed #include
      • SETJMP_H : Use of <setjmp.h>
      • SIGNAL_H : Use of <signal.h>
      • TGMATH_H : Use of <tgmath.h>
    • INCLUDE : Use of #include
    • INCLUDE_NEXT : Use of #include_next
    • INVALID : Invalid Preprocessor Directive
    • LINE : Use of #line
    • MACROARG : Preprocessing Directives in Macro Argument
    • MACROEND : Macro Does Not End With } or )
    • MACROSTART : Macro Does Not Start With { or (
    • MARGME : Macro Argument is both Mixed and Expanded
    • MDC : Macro Defines Constant
    • NBPE : Non-Boolean Preprocessor Expression
    • NOENDIF : No Matching #endif
    • NOFPAREN : Macro Parameter Not Parenthesized
    • NOIF : No Matching #if
    • PASTE : Macro Uses ## Operator
    • PASTEHASH : ## Follows # Operator
    • PRAGMA : Use of #pragma
    • RDEF : Macro Definition of Reserved Name
    • RECURSIVE : Recursive Macro
    • RUNDEF : Macro Undefinition of Reserved Name
    • STAR : Macro Uses Unary * Operator
    • UMIF : Undefined Macro in #if
    • UNBALANCED : Unbalanced Parenthesis
    • UNDEF : Use of #undef
    • UNDEFINFN : Macro Undefined in Function Body
    • USING : Use of #using
    • VARIADIC : Variadic Macro
    • WARNING : Use of #warning
  • STRUCT
    • ALIGNAS : Use of Alignas
      • EZA : Explicit Zero Alignment
      • IAS : Inconsistent Alignment Specifications
      • TMAS : Too Many Alignment Specifiers
    • ALIGNOF : Use of Alignof
    • ASSIGNRET : Inappropriate Assignment Operator Return
    • BGOTO : Backwards goto
    • BNC : Body Is Not Compound Statement
    • CALLSTACK : Excessive Stack Depth
    • CGEN : Use of C Generic
      • EMPE : Excessive Macro Parameter Evaluation in C Generic
      • IMPE : Inconsistent Macro Parameter Expansion in C Generic
      • MND : Missing Non-default Association in C Generic
      • MPD : Misplaced Default Association in C Generic
      • NOTMACRO : Selection in C Generic not Expanded from Macro Parameters
    • COMMA : Use of Comma Operator
    • CONDASSIG : Assignment in Conditional
    • CONTINUE : Continue Statement
    • CUP : Comparison of Unrelated Pointers
    • DBG : Leftover Debug Code
    • DECL
      • ANH : Anonymous Namespace in Header File
      • EAWS : Extern Array Without Size
      • FAM : Declaration of Flexible Array Member
      • FNEST : Nested Function Declaration
      • GLOBAL : Inappropriate Declaration in Global Namespace
      • IF : Inconsistent Function Declarations
      • IMPFN : Implicit Function Declaration
      • IMPT : Implicit Type
      • IO : Inconsistent Object Declarations
      • MG : Multiple Declarations of a Global
      • MGT : Global Variable Declared with Different Types
      • MISSINGDECL : No Previous Declaration
      • ML : Multiple Declarations On Line
      • MULTIEXT : Multiple External Declarations
      • NOEXT : Missing External Declaration
      • RESERVED : Declaration of Reserved Name
      • SAU : Specialization after Use
      • SNM : Modification of Standard Namespaces
      • VLA : Declaration of Variable Length Array
    • DEF
      • FDH : Function Defined in Header File
      • MULTIEXT : Multiple External Definitions
      • NOEXT : Missing External Definition
      • ODH : Object Defined in Header File
    • DNVD : delete with Non-Virtual Destructor
    • EBS : Empty {Branch, for, if, switch, while} Statement
      • Empty Branch Statement
      • Empty for Statement
      • Empty if Statement
      • Empty switch Statement
      • Empty while Statement
    • ELLIPSIS : Ellipsis
    • EXCP
      • CATCH : Use of catch
      • THROW : Use of throw
    • FNADDR : Implicit Address of Function
    • FUNCPTR
      • CALL : Function Pointer
      • CONVERT : Function Pointer Conversion
    • GLABEL : Label Not In Enclosing Block
    • GOTO : Goto Statement
    • ICOL : Inappropriate Call Outside Loop
    • ICVMF : Inappropriate Comparison of Virtual Member Function
    • INIT
      • CYCLE : Initialization Cycle
      • ENUM : Inconsistent Enumerator Initialization
      • ICDI : Inconsistent Chained Designator Initialization
      • MBI : Missing Braces in Initialization
      • OIE : Over-initialized Element
      • OOMI : Out of Order Member Initializers
      • PIAGG : Partially Uninitialized Aggregate
      • PIARR : Partially Uninitialized Array
      • UADI : Unspecified Array Size with Designator Initialization
      • UNORDERED : Unordered Initialization
    • LOOP
      • FPC : Float-typed Loop Counter
      • HR : High Risk Loop
      • MAE : Multiple Abnormal Loop Exits
      • MFINIT : Malformed for-loop Initialization
      • MFSTEP : Malformed for-loop Step
      • MFTERM : Malformed for-loop Condition
      • NOSTEP : Missing for-loop Step
      • NOTERM : Missing for-loop Termination
      • UB : Potential Unbounded Loop
    • MISRS : Misplaced Return Statement
    • MNR : Missing noreturn Specifier
    • MRS : Missing Return Statement
    • MULRS : Multiple Return Statements
    • MULTISTMT : Multiple Statements On Line
    • NBC : Condition Is Not Boolean
    • NOELSE : Missing Final else
    • NTAD : Null Test After Dereference
    • NVNR : Non-void noreturn
    • PARENS : Missing Parentheses
    • PARITH : Pointer Arithmetic
    • PBB : Pointer Before Beginning of Object
    • PIT : Pointer Type Inside Typedef
    • PPE : Pointer Past End of Object
    • RC : Redundant Condition
    • REGISTER : Register Keyword
    • RFCESH : Return from Computational Exception Signal Handler
    • RFNR : Return from noreturn
    • RPL : Return Pointer to Local
    • RPNTC : Returned Pointer Not Treated as const
    • SCOPE
      • FILE : Scope Could Be File Static
      • LOCAL : Scope Could Be Local Static
    • SE
      • ASSIGN : Too Many Side Effects in Assignment
      • CALL : Too Many Side Effects in Function Call
      • CGEN : Side Effects in C Generic Selection
      • COND : Condition Contains Side Effects
      • DEC : Side Effects in Expression with Decrement
      • ECOND : Too Many Side Effects in Condition
      • INC : Side Effects in Expression with Increment
      • INIT : Side Effects in Initializer List
      • IOE : Indeterminate Order of Evaluation
      • LOGIC : Side Effects in Logical Operand
      • SIZEOF : Side Effects in sizeof
      • STMT : Too Many Side Effects in Statement
      • SWITCH : Too Many Side Effects in Switch
    • SUP : Subtraction of Unrelated Pointers
    • SW
      • BAD : Malformed switch Statement
      • BOOL : Boolean switch Expression
      • IF : Too Few Cases in switch
      • MB : Missing break
      • MD : Missing default
      • MPC : Misplaced case
      • MPD : Misplaced default
      • SWNEE : switch With Non-enum Expression
    • TMD : Too Many Dereferences
    • TMID : Too Much Indirection in Declaration
    • TRIGRAPH : Trigraph
    • UA : Useless Assignment
    • UC : Unreachable Code: 5 warning classes
      • Unreachable Call
      • Unreachable Computation
      • Unreachable Conditional
      • Unreachable Control Flow
      • Unreachable Data Flow
    • UCTCH : Unreachable Catch
    • UESC : Unterminated Escape Sequence
    • UPD : Unchecked Parameter Dereference
    • USEASSIGN : Assignment Result in Expression
    • USING
      • DIRECTIVE : Using Directive
      • HDECL : Using Declaration in Header File
      • HDIR : Using Directive in Header File
      • MDECL : Misplaced Using Declaration
    • UULABEL : Unused Label
    • UUMACRO : Unused Macro
    • UUPARAM : Unused Parameter
    • UUTAG : Unused Tag
    • UUTYPE : Unused Type
    • UUVAL : Unused Value
    • UUVAR : Unused Variable
    • VCALL_IN_CTOR : Virtual Call in Constructor
    • VCALL_IN_DTOR : Virtual Call in Destructor
  • TYPE
    • AWID : Expression Value Widened by Assignment
    • BASIC : Basic Numerical Type Used
    • BCV : Virtual Base Class
    • BCVNID : Virtual Base Class not In Diamond
    • BCVNV : Virtual and Non-Virtual Base Class
    • BFINT : Inappropriate Bit-field Type
    • BFSHORT : Bit-field Too Short
    • BFSIGN : Bit-field Signedness Not Explicit
    • BFUNION : Bit-field in Union
    • CBCONST : Pointed-to Type Could Be const
    • CGEN
      • IAT : Inappropriate Association Type in C Generic
      • IMPTC : Implicit Pointer Type Conversion in Selection of C Generic
      • IST : Inappropriate Selection Type in C Generic
    • CSUF : Confusing Literal Suffix
    • IARGT
      • MEMCMP : Inappropriate Argument to memcmp
      • TGMATH : Inappropriate Argument to <tgmath.h> Macro
    • IAT : Inappropriate Assignment Type
    • ICA : Inappropriate Character Arithmetic
    • ICT : Inappropriate Cast Type
    • ICTE : Inappropriate Cast Type: Expression
    • IISVB : Implicit Inheritance from Stateful Virtual Base
    • INS : Inline Function Not static
    • IOT : Inappropriate Operand Type
    • IVD : Inappropriate Volatile Declaration
    • MAT : Mismatched Argument Types
    • MFCBCONST : Member Function Could Be const
    • MFCBSTATIC : Member Function Could Be static
    • MI
      • PBC : Multiple Inheritance with Public Base Class
      • PRIVI : Multiple Inheritance with Private Interface Class
      • PROTI : Multiple Inheritance with Protected Interface Class
      • TMPBC : Multiple Inheritance with Too Many Protected Base Classes
    • MOT : Mismatched Operand Types
    • MSUF : Missing Literal Suffix
    • MUDO : Missing User-defined Operations
    • NCS : Non-const String Literal
    • OC : Octal Constant
    • ONVM : Override of Non-Virtual Method
    • OWID : Expression Value Widened by Other Operand
    • RESTRICT : Restrict Qualifier Used
    • SAP : sizeof Array Parameter
    • TQFT : Type Qualifier on Function Type
    • UIGO : Unneeded Implicitly Generated Operations
    • UNF : Unnamed Field
    • UNION : Union Type
    • VCBC : Variable Could Be const
    • VMAT : Pointer to Variably-modified Array Type
• MATH : Math Library Usage
  • DOMAIN : Floating Point Domain Error
    • ATAN : Arctangent Domain Error
    • FE_INVALID : Raises FE_INVALID
    • LOG : Logarithm on Negative Value
    • POW : Undefined Power of Zero
    • SQRT : sqrt on Negative Value
    • TOOHIGH : Argument Too High
    • TOOLOW : Argument Too Low
  • RANGE : Floating Point Range Error
    • COSH
      • TOOHIGH : cosh on High Number
      • TOOLOW : cosh on Low Number
    • GAMMA : Gamma on Zero
    • LOG : Logarithm on Zero
  • TYPE
    • TGMATH
      • ITA : Inconsistent Types of Arguments to <tgmath.h> Macro
• MISC : Miscellaneous Warning Classes
  • CHROOT
    • NOCHDIR : chroot without chdir
  • CPE : Copy-Paste Error
  • CRYPTO
    • NOPAD : Encryption without Padding
    • TIMESEED : Predictable Seed in PRNG
  • FMT : Format String
  • FMTTYPE : Format String Type Error
  • MEM
    • NTERM : No Space For Null Terminator
      • CSTRING : Unterminated C String
    • OR : Overlapping Memory Regions
    • PROT : Memory Protection Removal
    • RPNT : Read Past Null Terminator
    • SIZE
      • ADDOFLOW : Addition Overflow of Size
      • BAD : Unreasonable Size Argument
      • MULOFLOW : Multiplication Overflow of Size
      • SUBUFLOW : Subtraction Underflow of Size
      • TRUNC : Truncation of Size
  • NEGCHAR : Negative Character Value
  • NOEFFECT : Function Call Has No Effect
  • NULLDACL : Null Security Descriptor
  • PADDING
    • POTB : Padding Passed Across a Trust Boundary
  • PATHLENGTH : MAX_PATH Exceeded
  • PWD
    • PLAIN : Plaintext Storage of Password
    • PLAINTRAN : Plaintext Transmission of Password
  • TIMEBOMB : Potential Timebomb
• PYTHON : Python Warning Classes
  • CONVENTION
    • BCA : Bad Classmethod Argument (Pylint)
    • BFE : Bad File Encoding (Pylint)
    • BMCA : Bad Mcs Classmethod Argument (Pylint)
    • BMMA : Bad Mcs Method Argument (Pylint)
    • CID : Consider Iterating Dictionary (Pylint)
    • CUDI : Consider Using Dict Items (Pylint)
    • CUE : Consider Using Enumerate (Pylint)
    • CUFS : Consider Using F String (Pylint)
    • DN : Disallowed Name (Pylint)
    • ED : Empty Docstring (Pylint)
    • ICID : Invalid Characters in Docstring (Pylint)
    • IN : Invalid Name (Pylint)
    • IOT : Import Outside Toplevel (Pylint)
    • LTL : Line Too Long (Pylint)
    • MCD : Missing Class Docstring (Pylint)
    • MFD : Missing Function Docstring (Pylint)
    • MFN : Missing Final Newline (Pylint)
    • MI : Multiple Imports (Pylint)
    • MLE : Mixed Line Endings (Pylint)
    • MMD : Missing Module Docstring (Pylint)
    • MS : Multiple Statements (Pylint)
    • NAMI : Non Ascii Module Import (Pylint)
    • NAN : Non Ascii Name (Pylint)
    • SC : Singleton Comparison (Pylint)
    • SP : Superfluous Parens (Pylint)
    • SSUFS : Single String Used for Slots (Pylint)
    • TDV : Typevar Double Variance (Pylint)
    • TML : Too Many Lines (Pylint)
    • TN : Trailing Newlines (Pylint)
    • TNIV : Typevar Name Incorrect Variance (Pylint)
    • TNM : Typevar Name Mismatch (Pylint)
    • TW : Trailing Whitespace (Pylint)
    • UDC : Unnecessary Dunder Call (Pylint)
    • UDLC : Unnecessary Direct Lambda Call (Pylint)
    • UI : Ungrouped Imports (Pylint)
    • UIA : Useless Import Alias (Pylint)
    • UIBNC : Use Implicit Booleaness Not Comparison (Pylint)
    • UIBNCTS : Use Implicit Booleaness Not Comparison to String (Pylint)
    • UIBNCTZ : Use Implicit Booleaness Not Comparison to Zero (Pylint)
    • UIBNL : Use Implicit Booleaness Not Len (Pylint)
    • ULA : Unnecessary Lambda Assignment (Pylint)
    • ULEF : Unexpected Line Ending Format (Pylint)
    • UMA : Use Maxsplit Arg (Pylint)
    • UN : Unnecessary Negation (Pylint)
    • USFI : Use Sequence for Iteration (Pylint)
    • UT : Unidiomatic Typecheck (Pylint)
    • WIO : Wrong Import Order (Pylint)
    • WIP : Wrong Import Position (Pylint)
    • WSIC : Wrong Spelling in Comment (Pylint)
    • WSID : Wrong Spelling in Docstring (Pylint)
  • ERROR
    • ACI : Abstract Class Instantiated (Pylint)
    • AFN : Assignment From None (Pylint)
    • AFNR : Assignment From No Return (Pylint)
    • AMBD : Access Member Before Definition (Pylint)
    • ANS : Assigning Non Slot (Pylint)
    • AOA : Await Outside Async (Pylint)
    • BCS : Bad Configuration Section (Pylint)
    • BEC : Bad Exception Cause (Pylint)
    • BEO : Bad Except Order (Pylint)
    • BFC : Bad Format Character (Pylint)
    • BPV : Bad Plugin Value (Pylint)
    • BRS : Bad Reversed Sequence (Pylint)
    • BSC : Bad Super Call (Pylint)
    • BSFT : Bad String Format Type (Pylint)
    • BSSC : Bad Str Strip Call (Pylint)
    • BU : Bidirectional Unicode (Pylint)
    • CIF : Continue in Finally (Pylint)
    • CNE : Catching Non Exception (Pylint)
    • CVSC : Class Variable Slots Conflict (Pylint)
    • DAN : Duplicate Argument Name (Pylint)
    • DB : Duplicate Bases (Pylint)
    • DIMI : Dict Iter Missing Items (Pylint)
    • FNM : Format Needs Mapping (Pylint)
    • FR : Function Redefined (Pylint)
    • IAF : Invalid All Format (Pylint)
    • IAO : Invalid All Object (Pylint)
    • ICB : Invalid Character Backspace (Pylint)
    • ICCR : Invalid Character Carriage Return (Pylint)
    • ICE : Invalid Character Esc (Pylint)
    • ICN : Invalid Character Nul (Pylint)
    • ICO : Invalid Class Object (Pylint)
    • ICS : Invalid Character Sub (Pylint)
    • ICZWS : Invalid Character Zero Width Space (Pylint)
    • IE : Import Error (Pylint)
    • IEE : Invalid Enum Extension (Pylint)
    • IEV : Invalid Envvar Value (Pylint)
    • IFC : Invalid Field Call (Pylint)
    • IFR : Invalid Format Returned (Pylint)
    • IGER : Invalid Getnewargs Ex Returned (Pylint)
    • IGR : Invalid Getnewargs Returned (Pylint)
    • IHR : Invalid Hash Returned (Pylint)
    • IIG : Init Is Generator (Pylint)
    • IIR : Invalid Index Returned (Pylint)
    • ILHR : Invalid Length Hint Returned (Pylint)
    • ILR : Invalid Length Returned (Pylint)
    • IMETACLS : Invalid Metaclass (Pylint)
    • IMRO : Inconsistent Mro (Pylint)
    • INBOOLRET : Invalid Bool Returned (Pylint)
    • INBYTERET : Invalid Bytes Returned (Pylint)
    • INC : Inherit Non Class (Pylint)
    • IRR : Invalid Repr Returned (Pylint)
    • IS : Invalid Slots (Pylint)
    • ISAT : Invalid Star Assignment Target (Pylint)
    • ISEQIDX : Invalid Sequence Index (Pylint)
    • ISLIDX : Invalid Slice Index (Pylint)
    • ISO : Invalid Slots Object (Pylint)
    • ISR : Invalid Str Returned (Pylint)
    • ISS : Invalid Slice Step (Pylint)
    • IUC : Invalid Unicode Codec (Pylint)
    • IUOT : Invalid Unary Operand Type (Pylint)
    • LFT : Logging Format Truncated (Pylint)
    • LTFA : Logging Too Few Args (Pylint)
    • LTMA : Logging Too Many Args (Pylint)
    • LUF : Logging Unsupported Format (Pylint)
    • MBR : Misplaced Bare Raise (Pylint)
    • MFF : Misplaced Format Function (Pylint)
    • MFS : Mixed Format String (Pylint)
    • MFSK : Missing Format String Key (Pylint)
    • MH : Method Hidden (Pylint)
    • MID : Modified Iterating Dict (Pylint)
    • MIS : Modified Iterating Set (Pylint)
    • MK : Missing Kwoa (Pylint)
    • NACM : Not Async Context Manager (Pylint)
    • NAG : Nonlocal and Global (Pylint)
    • NAI : Not an Iterable (Pylint)
    • NAM : Not a Mapping (Pylint)
    • NC : Not Callable (Pylint)
    • NCM : Not Context Manager (Pylint)
    • NIL : Not in Loop (Pylint)
    • NIR : Non Iterator Returned (Pylint)
    • NM : No Member (Pylint)
    • NMA : No Method Argument (Pylint)
    • NNIM : No Name in Module (Pylint)
    • NO : Nonexistent Operator (Pylint)
    • NR : Notimplemented Raised (Pylint)
    • NSA : No Self Argument (Pylint)
    • NVFP : No Value for Parameter (Pylint)
    • NWB : Nonlocal Without Binding (Pylint)
    • PIE : Potential Index Error (Pylint)
    • POAE : Positional Only Arguments Expected (Pylint)
    • RAIG : Return Arg in Generator (Pylint)
    • RBT : Raising Bad Type (Pylint)
    • RBTL : Relative Beyond Top Level (Pylint)
    • RII : Return in Init (Pylint)
    • RK : Repeated Keyword (Pylint)
    • RKA : Redundant Keyword Arg (Pylint)
    • RNE : Raising Non Exception (Pylint)
    • ROF : Return Outside Function (Pylint)
    • SE : Syntax Error (Pylint)
    • SF : Singledispatchmethod Function (Pylint)
    • SM : Singledispatch Method (Pylint)
    • SNAT : Star Needs Assignment Target (Pylint)
    • TFFA : Too Few Format Args (Pylint)
    • TFS : Truncated Format String (Pylint)
    • TMFARG : Too Many Format Args (Pylint)
    • TMFUNA : Too Many Function Args (Pylint)
    • TMSE : Too Many Star Expressions (Pylint)
    • UAO : Unsupported Assignment Operation (Pylint)
    • UAV : Undefined All Variable (Pylint)
    • UBA : Used Before Assignment (Pylint)
    • UBO : Unsupported Binary Operation (Pylint)
    • UDO : Unsupported Delete Operation (Pylint)
    • UIO : Unrecognized Inline Option (Pylint)
    • UKA : Unexpected Keyword Arg (Pylint)
    • UM : Unhashable Member (Pylint)
    • UMT : Unsupported Membership Test (Pylint)
    • UNS : Unpacking Non Sequence (Pylint)
    • UOBJ : Unsubscriptable Object (Pylint)
    • UOPT : Unrecognized Option (Pylint)
    • UPGD : Used Prior Global Declaration (Pylint)
    • USMS : Unexpected Special Method Signature (Pylint)
    • UV : Undefined Variable (Pylint)
    • YIAF : Yield Inside Async Function (Pylint)
    • YOF : Yield Outside Function (Pylint)
  • FAILURE
    • AE : Astroid Error (Pylint)
    • CPE : Config Parse Error (Pylint)
    • FATAL : Fatal (Pylint)
    • MCF : Method Check Failed (Pylint)
    • PE : Parse Error (Pylint)
  • INFORMATIONAL
    • BIO : Bad Inline Option (Pylint)
    • CENM : C Extension No Member (Pylint)
    • DP : Deprecated Pragma (Pylint)
    • FI : File Ignored (Pylint)
    • LD : Locally Disabled (Pylint)
    • RCF : Raw Checker Failed (Pylint)
    • SM : Suppressed Message (Pylint)
    • US : Useless Suppression (Pylint)
    • USMI : Use Symbolic Message Instead (Pylint)
  • REFACTOR
    • CC : Chained Comparison (Pylint)
    • CETC : Condition Evals to Constant (Pylint)
    • CI : Cyclic Import (Pylint)
    • CMI : Consider Merging Isinstance (Pylint)
    • COC : Comparison of Constants (Pylint)
    • CSV : Consider Swap Variables (Pylint)
    • CUDC : Consider Using Dict Comprehension (Pylint)
    • CUFI : Consider Using From Import (Pylint)
    • CUGEN : Consider Using Generator (Pylint)
    • CUGET : Consider Using Get (Pylint)
    • CUI : Consider Using in (Pylint)
    • CUJ : Consider Using Join (Pylint)
    • CUMAXB : Consider Using Max Builtin (Pylint)
    • CUMINB : Consider Using Min Builtin (Pylint)
    • CUSC : Consider Using Set Comprehension (Pylint)
    • CUSE : Consider Using Sys Exit (Pylint)
    • CUT : Consider Using Ternary (Pylint)
    • CUW : Consider Using With (Pylint)
    • CWI : Comparison With Itself (Pylint)
    • DC : Duplicate Code (Pylint)
    • IRS : Inconsistent Return Statements (Pylint)
    • LC : Literal Comparison (Pylint)
    • NCD : No Classmethod Decorator (Pylint)
    • NEB : No Else Break (Pylint)
    • NEC : No Else Continue (Pylint)
    • NERET : No Else Return (Pylint)
    • NERSE : No Else Raise (Pylint)
    • NSD : No Staticmethod Decorator (Pylint)
    • PWP : Property With Parameters (Pylint)
    • RAFL : Redefined Argument From Local (Pylint)
    • SBE : Simplify Boolean Expression (Pylint)
    • SC : Simplifiable Condition (Pylint)
    • SIE : Simplifiable If Expression (Pylint)
    • SIR : Stop Iteration Return (Pylint)
    • SIS : Simplifiable If Statement (Pylint)
    • SWA : Super With Arguments (Pylint)
    • TCT : Trailing Comma Tuple (Pylint)
    • TFPM : Too Few Public Methods (Pylint)
    • TMANC : Too Many Ancestors (Pylint)
    • TMARG : Too Many Arguments (Pylint)
    • TMB : Too Many Branches (Pylint)
    • TMBE : Too Many Boolean Expressions (Pylint)
    • TMIA : Too Many Instance Attributes (Pylint)
    • TML : Too Many Locals (Pylint)
    • TMNB : Too Many Nested Blocks (Pylint)
    • TMPM : Too Many Public Methods (Pylint)
    • TMRS : Too Many Return Statements (Pylint)
    • TMS : Too Many Statements (Pylint)
    • UAG : Use a Generator (Pylint)
    • UC : Unnecessary Comprehension (Pylint)
    • UDIL : Unnecessary Dict Index Lookup (Pylint)
    • UDL : Use Dict Literal (Pylint)
    • ULIL : Unnecessary List Index Lookup (Pylint)
    • ULL : Use List Literal (Pylint)
    • UOI : Useless Object Inheritance (Pylint)
    • UOV : Useless Option Value (Pylint)
    • UR : Useless Return (Pylint)
  • WARNING
    • ABIS : Anomalous Backslash in String (Pylint)
    • AD : Arguments Differ (Pylint)
    • ADOI : Attribute Defined Outside Init (Pylint)
    • AM : Abstract Method (Pylint)
    • AOOO : Arguments Out of Order (Pylint)
    • AOSL : Assert on String Literal (Pylint)
    • AOT : Assert on Tuple (Pylint)
    • AR : Arguments Renamed (Pylint)
    • AUEIS : Anomalous Unicode Escape in String (Pylint)
    • BCC : Bad Chained Comparison (Pylint)
    • BD : Boolean Datetime (Pylint)
    • BE : Bare Except (Pylint)
    • BEC : Broad Exception Caught (Pylint)
    • BER : Broad Exception Raised (Pylint)
    • BFS : Bad Format String (Pylint)
    • BFSK : Bad Format String Key (Pylint)
    • BI : Bad Indentation (Pylint)
    • BOE : Binary Op Exception (Pylint)
    • BOM : Bad Open Mode (Pylint)
    • BSA : Bad Staticmethod Argument (Pylint)
    • BTI : Bad Thread Instantiation (Pylint)
    • CVFL : Cell Var From Loop (Pylint)
    • CWC : Comparison With Callable (Pylint)
    • CWS : Confusing With Statement (Pylint)
    • DA : Deprecated Argument (Pylint)
    • DC : Deprecated Class (Pylint)
    • DD : Deprecated Decorator (Pylint)
    • DDV : Dangerous Default Value (Pylint)
    • DE : Duplicate Except (Pylint)
    • DK : Duplicate Key (Pylint)
    • DMETH : Deprecated Method (Pylint)
    • DMOD : Deprecated Module (Pylint)
    • DSFA : Duplicate String Formatting Argument (Pylint)
    • DV : Duplicate Value (Pylint)
    • ENA : Expression Not Assigned (Pylint)
    • EVALU : Eval Used (Pylint)
    • EXECU : Exec Used (Pylint)
    • FCS : Format Combined Specification (Pylint)
    • FDS : Forgotten Debug Statement (Pylint)
    • FIXME : Fixme (Pylint)
    • FMTSWI : Format String Without Interpolation (Pylint)
    • FSTRWI : F String Without Interpolation (Pylint)
    • GAML : Global at Module Level (Pylint)
    • GS : Global Statement (Pylint)
    • GVNA : Global Variable Not Assigned (Pylint)
    • GVU : Global Variable Undefined (Pylint)
    • IED : Invalid Envvar Default (Pylint)
    • IFA : Implicit Flag Alias (Pylint)
    • IFI : Invalid Format Index (Pylint)
    • IOM : Invalid Overridden Method (Pylint)
    • IQ : Inconsistent Quotes (Pylint)
    • IS : Import Self (Pylint)
    • ISANVT : Isinstance Second Argument Not Valid Type (Pylint)
    • ISC : Implicit Str Concat (Pylint)
    • KABV : Keyword Arg Before Vararg (Pylint)
    • KSBPA : Kwarg Superseded By Positional Arg (Pylint)
    • LE : Lost Exception (Pylint)
    • LFMTI : Logging Format Interpolation (Pylint)
    • LFSTRI : Logging Fstring Interpolation (Pylint)
    • LNL : Logging Not Lazy (Pylint)
    • MCMSN : Method Cache Max Size None (Pylint)
    • MF : Misplaced Future (Pylint)
    • MFA : Missing Format Attribute (Pylint)
    • MFAK : Missing Format Argument Key (Pylint)
    • MIL : Modified Iterating List (Pylint)
    • MPFCIT : Missing Parentheses for Call in Test (Pylint)
    • MT : Missing Timeout (Pylint)
    • NAFN : Non Ascii File Name (Pylint)
    • NC : Nan Comparison (Pylint)
    • NEWC : Named Expr Without Context (Pylint)
    • NMM : Nested Min Max (Pylint)
    • NPIC : Non Parent Init Called (Pylint)
    • NSATDN : Non Str Assignment to Dunder Name (Pylint)
    • OFM : Overridden Final Method (Pylint)
    • PA : Protected Access (Pylint)
    • PES : Pointless Exception Statement (Pylint)
    • PM : Preferred Module (Pylint)
    • PS : Pointless Statement (Pylint)
    • PSS : Pointless String Statement (Pylint)
    • PUV : Possibly Unused Variable (Pylint)
    • RAN : Redeclared Assigned Name (Pylint)
    • RB : Redefined Builtin (Pylint)
    • REIMPORTED : Reimported (Pylint)
    • RFT : Raising Format Tuple (Pylint)
    • RIF : Return in Finally (Pylint)
    • RMF : Raise Missing From (Pylint)
    • RON : Redefined Outer Name (Pylint)
    • RSIS : Redefined Slots in Subclass (Pylint)
    • RUA : Redundant Unittest Assert (Pylint)
    • RUSP : Redundant U String Prefix (Pylint)
    • SAV : Self Assigning Variable (Pylint)
    • SCA : Self Cls Assignment (Pylint)
    • SCE : Shallow Copy Environ (Pylint)
    • SD : Signature Differs (Pylint)
    • SFC : Subclassed Final Class (Pylint)
    • SI : Shadowed Import (Pylint)
    • SINC : Super Init Not Called (Pylint)
    • SPPF : Subprocess Popen Preexec Fn (Pylint)
    • SRC : Subprocess Run Check (Pylint)
    • SWB : Super Without Brackets (Pylint)
    • TER : Try Except Raise (Pylint)
    • UA : Unused Argument (Pylint)
    • UCT : Using Constant Test (Pylint)
    • UDU : Unbalanced Dict Unpacking (Pylint)
    • UELL : Unnecessary Ellipsis (Pylint)
    • UENC : Unspecified Encoding (Pylint)
    • UEOL : Useless Else on Loop (Pylint)
    • UFDIUV : Using Final Decorator in Unsupported Version (Pylint)
    • UFSA : Unused Format String Argument (Pylint)
    • UFSIUV : Using F String in Unsupported Version (Pylint)
    • UFSK : Unused Format String Key (Pylint)
    • UI : Unused Import (Pylint)
    • UL : Unnecessary Lambda (Pylint)
    • ULV : Undefined Loop Variable (Pylint)
    • UNREACHABLE : Unreachable (Pylint)
    • UOV : Unknown Option Value (Pylint)
    • UP : Unnecessary Pass (Pylint)
    • UPD : Useless Parent Delegation (Pylint)
    • UPM : Unused Private Member (Pylint)
    • US : Unnecessary Semicolon (Pylint)
    • UTU : Unbalanced Tuple Unpacking (Pylint)
    • UV : Unused Variable (Pylint)
    • UWI : Unused Wildcard Import (Pylint)
    • UWL : Useless With Lock (Pylint)
    • WEO : Wrong Exception Operation (Pylint)
    • WI : Wildcard Import (Pylint)
• ROSLYN : Warnings Detected by Roslyn
  • DESIGN
    • CA1000 : Do not declare static members on generic types (C#)
    • CA1001 : Types that own disposable fields should be disposable (C#)
    • CA1002 : Do not expose generic lists (C#)
    • CA1003 : Use generic event handler instances (C#)
    • CA1005 : Avoid excessive parameters on generic types (C#)
    • CA1008 : Enums should have zero value (C#)
    • CA1010 : Generic interface should also be implemented (C#)
    • CA1012 : Abstract types should not have public constructors (C#)
    • CA1014 : Mark assemblies with CLSCompliant (C#)
    • CA1016 : Mark assemblies with assembly version (C#)
    • CA1017 : Mark assemblies with ComVisible (C#)
    • CA1018 : Mark attributes with AttributeUsageAttribute (C#)
    • CA1019 : Define accessors for attribute arguments (C#)
    • CA1021 : Avoid out parameters (C#)
    • CA1024 : Use properties where appropriate (C#)
    • CA1027 : Mark enums with FlagsAttribute (C#)
    • CA1028 : Enum Storage should be Int32 (C#)
    • CA1030 : Use events where appropriate (C#)
    • CA1031 : Do not catch general exception types (C#)
    • CA1032 : Implement standard exception constructors (C#)
    • CA1033 : Interface methods should be callable by child types (C#)
    • CA1034 : Nested types should not be visible (C#)
    • CA1036 : Override methods on comparable types (C#)
    • CA1040 : Avoid empty interfaces (C#)
    • CA1041 : Provide ObsoleteAttribute message (C#)
    • CA1043 : Use Integral Or String Argument For Indexers (C#)
    • CA1044 : Properties should not be write only (C#)
    • CA1045 : Do not pass types by reference (C#)
    • CA1046 : Do not overload equality operator on reference types (C#)
    • CA1047 : Do not declare protected member in sealed type (C#)
    • CA1050 : Declare types in namespaces (C#)
    • CA1051 : Do not declare visible instance fields (C#)
    • CA1052 : Static holder types should be Static or NotInheritable (C#)
    • CA1054 : URI-like parameters should not be strings (C#)
    • CA1055 : URI-like return values should not be strings (C#)
    • CA1056 : URI-like properties should not be strings (C#)
    • CA1058 : Types should not extend certain base types (C#)
    • CA1060 : Move pinvokes to native methods class (C#)
    • CA1061 : Do not hide base class methods (C#)
    • CA1062 : Validate arguments of public methods (C#)
    • CA1063 : Implement IDisposable Correctly (C#)
    • CA1064 : Exceptions should be public (C#)
    • CA1065 : Do not raise exceptions in unexpected locations (C#)
    • CA1066 : Implement IEquatable when overriding Object.Equals (C#)
    • CA1067 : Override Object.Equals(object) when implementing IEquatable<T> (C#)
    • CA1068 : CancellationToken parameters must come last (C#)
    • CA1069 : Enums values should not be duplicated (C#)
    • CA1070 : Do not declare event fields as virtual (C#)
  • DOCUMENTATION
    • CA1200 : Avoid using cref tags with a prefix (C#)
  • GLOBALIZATION
    • CA1303 : Do not pass literals as localized parameters (C#)
    • CA1304 : Specify CultureInfo (C#)
    • CA1305 : Specify IFormatProvider (C#)
    • CA1307 : Specify StringComparison for clarity (C#)
    • CA1308 : Normalize strings to uppercase (C#)
    • CA1309 : Use ordinal string comparison (C#)
    • CA1310 : Specify StringComparison for correctness (C#)
    • CA1311 : Specify a culture or use an invariant version (C#)
    • CA2101 : Specify marshaling for P/Invoke string arguments (C#)
  • INTEROPERABILITY
    • CA1401 : P/Invokes should not be visible (C#)
    • CA1416 : Validate platform compatibility (C#)
    • CA1417 : Do not use 'OutAttribute' on string parameters for P/Invokes (C#)
    • CA1418 : Use valid platform string (C#)
    • CA1419 : Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle' (C#)
    • CA1420 : Property, type, or attribute requires runtime marshalling (C#)
    • CA1421 : This method uses runtime marshalling even when the 'DisableRuntimeMarshallingAttribute' is applied (C#)
    • CA1422 : Validate platform compatibility - obsoleted APIs (C#)
  • MAINTAINABILITY
    • CA1501 : Avoid excessive inheritance (C#)
    • CA1502 : Avoid excessive complexity (C#)
    • CA1505 : Avoid unmaintainable code (C#)
    • CA1506 : Avoid excessive class coupling (C#)
    • CA1507 : Use nameof to express symbol names (C#)
    • CA1508 : Avoid dead conditional code (C#)
    • CA1509 : Invalid entry in code metrics rule specification file (C#)
    • CA1510 : Use ArgumentNullException throw helper (C#)
    • CA1511 : Use ArgumentException throw helper (C#)
    • CA1512 : Use ArgumentOutOfRangeException throw helper (C#)
    • CA1513 : Use ObjectDisposedException throw helper (C#)
  • NAMING
    • CA1700 : Do not name enum values 'Reserved' (C#)
    • CA1707 : Identifiers should not contain underscores (C#)
    • CA1708 : Identifiers should differ by more than case (C#)
    • CA1710 : Identifiers should have correct suffix (C#)
    • CA1711 : Identifiers should not have incorrect suffix (C#)
    • CA1712 : Do not prefix enum values with type name (C#)
    • CA1713 : Events should not have 'Before' or 'After' prefix (C#)
    • CA1715 : Identifiers should have correct prefix (C#)
    • CA1716 : Identifiers should not match keywords (C#)
    • CA1720 : Identifier contains type name (C#)
    • CA1721 : Property names should not match get methods (C#)
    • CA1724 : Type names should not match namespaces (C#)
    • CA1725 : Parameter names should match base declaration (C#)
    • CA1727 : Use PascalCase for named placeholders (C#)
  • PERFORMANCE
    • CA1802 : Use literals where appropriate (C#)
    • CA1805 : Do not initialize unnecessarily (C#)
    • CA1806 : Do not ignore method results (C#)
    • CA1810 : Initialize reference type static fields inline (C#)
    • CA1812 : Avoid uninstantiated internal classes (C#)
    • CA1813 : Avoid unsealed attributes (C#)
    • CA1814 : Prefer jagged arrays over multidimensional (C#)
    • CA1815 : Override equals and operator equals on value types (C#)
    • CA1819 : Properties should not return arrays (C#)
    • CA1820 : Test for empty strings using string length (C#)
    • CA1821 : Remove empty Finalizers (C#)
    • CA1822 : Mark members as static (C#)
    • CA1823 : Avoid unused private fields (C#)
    • CA1824 : Mark assemblies with NeutralResourcesLanguageAttribute (C#)
    • CA1825 : Avoid zero-length array allocations (C#)
    • CA1826 : Do not use Enumerable methods on indexable collections (C#)
    • CA1827 : Do not use Count() or LongCount() when Any() can be used (C#)
    • CA1828 : Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used (C#)
    • CA1829 : Use Length/Count property instead of Count() when available (C#)
    • CA1830 : Prefer strongly-typed Append and Insert method overloads on StringBuilder (C#)
    • CA1831 : Use AsSpan or AsMemory instead of Range-based indexers when appropriate (C#)
    • CA1832 : Use AsSpan or AsMemory instead of Range-based indexers (C#)
    • CA1833 : Use AsSpan or AsMemory instead of Range-based indexers for getting Span of an array (C#)
    • CA1834 : Consider using 'StringBuilder.Append(char)' when applicable (C#)
    • CA1835 : Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync' (C#)
    • CA1836 : Prefer IsEmpty over Count (C#)
    • CA1837 : Use 'Environment.ProcessId' (C#)
    • CA1838 : Avoid 'StringBuilder' parameters for P/Invokes (C#)
    • CA1839 : Use 'Environment.ProcessPath' (C#)
    • CA1840 : Use 'Environment.CurrentManagedThreadId' (C#)
    • CA1841 : Prefer Dictionary.Contains methods (C#)
    • CA1842 : Do not use 'WhenAll' with a single task (C#)
    • CA1843 : Do not use 'WaitAll' with a single task (C#)
    • CA1844 : Provide memory-based overrides of async methods when subclassing 'Stream' (C#)
    • CA1845 : Use span-based 'string.Concat' (C#)
    • CA1846 : Prefer 'AsSpan' over 'Substring' (C#)
    • CA1847 : Use char literal for a single character lookup (C#)
    • CA1848 : Use the LoggerMessage delegates (C#)
    • CA1849 : Call async methods when in an async method (C#)
    • CA1850 : Prefer static 'HashData' method over 'ComputeHash' (C#)
    • CA1851 : Possible multiple enumerations of 'IEnumerable' collection (C#)
    • CA1852 : Seal internal types (C#)
    • CA1853 : Unnecessary call to 'Dictionary.ContainsKey(key)' (C#)
    • CA1854 : Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method (C#)
    • CA1855 : Prefer 'Clear' over 'Fill' (C#)
    • CA1856 : Incorrect usage of ConstantExpected attribute (C#)
    • CA1857 : A constant is expected for the parameter (C#)
    • CA1858 : Use 'StartsWith' instead of 'IndexOf' (C#)
    • CA1859 : Use concrete types when possible for improved performance (C#)
    • CA1860 : Avoid using 'Enumerable.Any()' extension method (C#)
    • CA1861 : Avoid constant arrays as arguments (C#)
    • CA1862 : Use the 'StringComparison' method overloads to perform case-insensitive string comparisons (C#)
    • CA1863 : Use 'CompositeFormat' (C#)
    • CA1864 : Prefer the 'IDictionary.TryAdd(TKey, TValue)' method (C#)
    • CA1865 : Use char overload, CA1865 (C#)
    • CA1866 : Use char overload, CA1866 (C#)
    • CA1867 : Use char overload, CA1867 (C#)
    • CA1868 : Unnecessary call to 'Contains(item)' (C#)
    • CA1869 : Cache and reuse 'JsonSerializerOptions' instances (C#)
    • CA1870 : Use a cached 'SearchValues' instance (C#)
  • RELIABILITY
    • CA2000 : Dispose objects before losing scope (C#)
    • CA2002 : Do not lock on objects with weak identity (C#)
    • CA2007 : Consider calling ConfigureAwait on the awaited task (C#)
    • CA2008 : Do not create tasks without passing a TaskScheduler (C#)
    • CA2009 : Do not call ToImmutableCollection on an ImmutableCollection value (C#)
    • CA2011 : Avoid infinite recursion (C#)
    • CA2012 : Use ValueTasks correctly (C#)
    • CA2013 : Do not use ReferenceEquals with value types (C#)
    • CA2014 : Do not use stackalloc in loops (C#)
    • CA2015 : Do not define finalizers for types derived from MemoryManager<T> (C#)
    • CA2016 : Forward the 'CancellationToken' parameter to methods (C#)
    • CA2017 : Parameter count mismatch (C#)
    • CA2018 : 'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument (C#)
    • CA2019 : Improper 'ThreadStatic' field initialization (C#)
    • CA2020 : Prevent behavioral change (C#)
    • CA2021 : Do not call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types (C#)
  • SECURITY
    • CA2100 : Review SQL queries for security vulnerabilities (C#)
    • CA2119 : Seal methods that satisfy private interfaces (C#)
    • CA2153 : Do Not Catch Corrupted State Exceptions (C#)
    • CA2300 : Do not use insecure deserializer BinaryFormatter (C#)
    • CA2301 : Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder (C#)
    • CA2302 : Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize (C#)
    • CA2305 : Do not use insecure deserializer LosFormatter (C#)
    • CA2310 : Do not use insecure deserializer NetDataContractSerializer (C#)
    • CA2311 : Do not deserialize without first setting NetDataContractSerializer.Binder (C#)
    • CA2312 : Ensure NetDataContractSerializer.Binder is set before deserializing (C#)
    • CA2315 : Do not use insecure deserializer ObjectStateFormatter (C#)
    • CA2321 : Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver (C#)
    • CA2322 : Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing (C#)
    • CA2326 : Do not use TypeNameHandling values other than None (C#)
    • CA2327 : Do not use insecure JsonSerializerSettings (C#)
    • CA2328 : Ensure that JsonSerializerSettings are secure (C#)
    • CA2329 : Do not deserialize with JsonSerializer using an insecure configuration (C#)
    • CA2330 : Ensure that JsonSerializer has a secure configuration when deserializing (C#)
    • CA2350 : Do not use DataTable.ReadXml() with untrusted data (C#)
    • CA2351 : Do not use DataSet.ReadXml() with untrusted data (C#)
    • CA2352 : Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks (C#)
    • CA2353 : Unsafe DataSet or DataTable in serializable type (C#)
    • CA2354 : Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attacks (C#)
    • CA2355 : Unsafe DataSet or DataTable type found in deserializable object graph (C#)
    • CA2356 : Unsafe DataSet or DataTable type in web deserializable object graph (C#)
    • CA2361 : Ensure auto-generated class containing DataSet.ReadXml() is not used with untrusted data (C#)
    • CA2362 : Unsafe DataSet or DataTable in auto-generated serializable type can be vulnerable to remote code execution attacks (C#)
    • CA3001 : Review code for SQL injection vulnerabilities (C#)
    • CA3002 : Review code for XSS vulnerabilities (C#)
    • CA3003 : Review code for file path injection vulnerabilities (C#)
    • CA3004 : Review code for information disclosure vulnerabilities (C#)
    • CA3005 : Review code for LDAP injection vulnerabilities (C#)
    • CA3006 : Review code for process command injection vulnerabilities (C#)
    • CA3007 : Review code for open redirect vulnerabilities (C#)
    • CA3008 : Review code for XPath injection vulnerabilities (C#)
    • CA3009 : Review code for XML injection vulnerabilities (C#)
    • CA3010 : Review code for XAML injection vulnerabilities (C#)
    • CA3011 : Review code for DLL injection vulnerabilities (C#)
    • CA3012 : Review code for regex injection vulnerabilities (C#)
    • CA3061 : Do Not Add Schema By URL (C#)
    • CA3075 : Insecure DTD processing in XML (C#)
    • CA3076 : Insecure XSLT script processing (C#)
    • CA3077 : Insecure Processing in API Design, XmlDocument and XmlTextReader (C#)
    • CA3147 : Mark Verb Handlers With Validate Antiforgery Token (C#)
    • CA5350 : Do Not Use Weak Cryptographic Algorithms (C#)
    • CA5351 : Do Not Use Broken Cryptographic Algorithms (C#)
    • CA5358 : Review cipher mode usage with cryptography experts (C#)
    • CA5359 : Do Not Disable Certificate Validation (C#)
    • CA5360 : Do Not Call Dangerous Methods In Deserialization (C#)
    • CA5361 : Do Not Disable SChannel Use of Strong Crypto (C#)
    • CA5362 : Potential reference cycle in deserialized object graph (C#)
    • CA5363 : Do Not Disable Request Validation (C#)
    • CA5364 : Do Not Use Deprecated Security Protocols (C#)
    • CA5365 : Do Not Disable HTTP Header Checking (C#)
    • CA5366 : Use XmlReader for 'DataSet.ReadXml()' (C#)
    • CA5367 : Do Not Serialize Types With Pointer Fields (C#)
    • CA5368 : Set ViewStateUserKey For Classes Derived From Page (C#)
    • CA5369 : Use XmlReader for 'XmlSerializer.Deserialize()' (C#)
    • CA5370 : Use XmlReader for XmlValidatingReader constructor (C#)
    • CA5371 : Use XmlReader for 'XmlSchema.Read()' (C#)
    • CA5372 : Use XmlReader for XPathDocument constructor (C#)
    • CA5373 : Do not use obsolete key derivation function (C#)
    • CA5374 : Do Not Use XslTransform (C#)
    • CA5375 : Do Not Use Account Shared Access Signature (C#)
    • CA5376 : Use SharedAccessProtocol HttpsOnly (C#)
    • CA5377 : Use Container Level Access Policy (C#)
    • CA5378 : Do not disable ServicePointManagerSecurityProtocols (C#)
    • CA5379 : Ensure Key Derivation Function algorithm is sufficiently strong (C#)
    • CA5380 : Do Not Add Certificates To Root Store (C#)
    • CA5381 : Ensure Certificates Are Not Added To Root Store (C#)
    • CA5382 : Use Secure Cookies In ASP.NET Core (C#)
    • CA5383 : Ensure Use Secure Cookies In ASP.NET Core (C#)
    • CA5384 : Do Not Use Digital Signature Algorithm (DSA) (C#)
    • CA5385 : Use Rivest-Shamir-Adleman (RSA) Algorithm With Sufficient Key Size (C#)
    • CA5386 : Avoid hardcoding SecurityProtocolType value (C#)
    • CA5387 : Do Not Use Weak Key Derivation Function With Insufficient Iteration Count (C#)
    • CA5388 : Ensure Sufficient Iteration Count When Using Weak Key Derivation Function (C#)
    • CA5389 : Do Not Add Archive Item's Path To The Target File System Path (C#)
    • CA5390 : Do not hard-code encryption key (C#)
    • CA5391 : Use antiforgery tokens in ASP.NET Core MVC controllers (C#)
    • CA5392 : Use DefaultDllImportSearchPaths attribute for P/Invokes (C#)
    • CA5393 : Do not use unsafe DllImportSearchPath value (C#)
    • CA5394 : Do not use insecure randomness (C#)
    • CA5395 : Miss HttpVerb attribute for action methods (C#)
    • CA5396 : Set HttpOnly to true for HttpCookie (C#)
    • CA5397 : Do not use deprecated SslProtocols values (C#)
    • CA5398 : Avoid hardcoded SslProtocols values (C#)
    • CA5399 : HttpClients should enable certificate revocation list checks (C#)
    • CA5400 : Ensure HttpClient certificate revocation list check is not disabled (C#)
    • CA5401 : Do not use CreateEncryptor with non-default IV (C#)
    • CA5402 : Use CreateEncryptor with the default IV (C#)
    • CA5403 : Do not hard-code certificate (C#)
    • CA5404 : Do not disable token validation checks (C#)
    • CA5405 : Do not always skip token validation in delegates (C#)
  • USAGE
    • CA1816 : Dispose methods should call SuppressFinalize (C#)
    • CA2200 : Rethrow to preserve stack details (C#)
    • CA2201 : Do not raise reserved exception types (C#)
    • CA2207 : Initialize value type static fields inline (C#)
    • CA2208 : Instantiate argument exceptions correctly (C#)
    • CA2211 : Non-constant fields should not be visible (C#)
    • CA2213 : Disposable fields should be disposed (C#)
    • CA2214 : Do not call overridable methods in constructors (C#)
    • CA2215 : Dispose methods should call base class dispose (C#)
    • CA2216 : Disposable types should declare finalizer (C#)
    • CA2217 : Do not mark enums with FlagsAttribute (C#)
    • CA2219 : Do not raise exceptions in finally clauses (C#)
    • CA2225 : Operator overloads have named alternates (C#)
    • CA2226 : Operators should have symmetrical overloads (C#)
    • CA2227 : Collection properties should be read only (C#)
    • CA2231 : Overload operator equals on overriding value type Equals (C#)
    • CA2234 : Pass system uri objects instead of strings (C#)
    • CA2235 : Mark all non-serializable fields (C#)
    • CA2237 : Mark ISerializable types with serializable (C#)
    • CA2241 : Provide correct arguments to formatting methods (C#)
    • CA2242 : Test for NaN correctly (C#)
    • CA2243 : Attribute string literals should parse correctly (C#)
    • CA2244 : Do not duplicate indexed element initializations (C#)
    • CA2245 : Do not assign a property to itself (C#)
    • CA2246 : Assigning symbol and its member in the same statement (C#)
    • CA2247 : Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum (C#)
    • CA2248 : Provide correct 'enum' argument to 'Enum.HasFlag' (C#)
    • CA2249 : Consider using 'string.Contains' instead of 'string.IndexOf' (C#)
    • CA2250 : Use 'ThrowIfCancellationRequested' (C#)
    • CA2251 : Use 'string.Equals' (C#)
    • CA2252 : This API requires opting into preview features (C#)
    • CA2253 : Named placeholders should not be numeric values (C#)
    • CA2254 : Template should be a static expression (C#)
    • CA2255 : The 'ModuleInitializer' attribute should not be used in libraries (C#)
    • CA2256 : All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface (C#)
    • CA2257 : Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static' (C#)
    • CA2258 : Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported (C#)
    • CA2259 : 'ThreadStatic' only affects static fields (C#)
    • CA2260 : Use correct type parameter (C#)
    • CA2261 : Do not use ConfigureAwaitOptions.SuppressThrowing with Task<TResult> (C#)
• RUST : Rust Warning Classes
  • CARGO
    • CCM : Cargo Common Metadata (Rust Clippy)
    • MCV : Multiple Crate Versions (Rust Clippy)
    • NFN : Negative Feature Names (Rust Clippy)
    • RFN : Redundant Feature Names (Rust Clippy)
    • WD : Wildcard Dependencies (Rust Clippy)
  • COMPLEXITY
    • BB : Borrowed Box (Rust Clippy)
    • BC : Bool Comparison (Rust Clippy)
    • BCTL : Bytes Count to Len (Rust Clippy)
    • BDR : Borrow Deref Ref (Rust Clippy)
    • BIOM : Bind Instead of Map (Rust Clippy)
    • CLAU : Char Lit As U8 (Rust Clippy)
    • COC : Clone on Copy (Rust Clippy)
    • CT : Crosspointer Transmute (Rust Clippy)
    • DA : Deref Addrof (Rust Clippy)
    • DC : Double Comparisons (Rust Clippy)
    • DCA : Deprecated Cfg Attr (Rust Clippy)
    • DCUS : Default Constructed Unit Structs (Rust Clippy)
    • DI : Derivable Impls (Rust Clippy)
    • DP : Double Parens (Rust Clippy)
    • DS : Duration Subsec (Rust Clippy)
    • DSE : Diverging Sub Expression (Rust Clippy)
    • EAD : Explicit Auto Deref (Rust Clippy)
    • ECL : Explicit Counter Loop (Rust Clippy)
    • EN : Excessive Nesting (Rust Clippy)
    • EUL : Extra Unused Lifetimes (Rust Clippy)
    • EUTP : Extra Unused Type Parameters (Rust Clippy)
    • EW : Explicit Write (Rust Clippy)
    • FLATMAPID : Flat Map Identity (Rust Clippy)
    • FLTMAPID : Filter Map Identity (Rust Clippy)
    • FN : Filter Next (Rust Clippy)
    • GLWL : Get Last With Len (Rust Clippy)
    • IC : Iter Count (Rust Clippy)
    • IFE : Inspect for Each (Rust Clippy)
    • IKM : Iter Kv Map (Rust Clippy)
    • IO : Identity Op (Rust Clippy)
    • IPO : Int Plus One (Rust Clippy)
    • LWTU : Let With Type Underscore (Rust Clippy)
    • MAPFLAT : Map Flatten (Rust Clippy)
    • MAR : Match As Ref (Rust Clippy)
    • MFIND : Manual Find (Rust Clippy)
    • MFLAT : Manual Flatten (Rust Clippy)
    • MFLT : Manual Filter (Rust Clippy)
    • MFLTMAP : Manual Filter Map (Rust Clippy)
    • MFNDMAP : Manual Find Map (Rust Clippy)
    • MHO : Manual Hash One (Rust Clippy)
    • MI : Map Identity (Rust Clippy)
    • MMSS : Manual Main Separator Str (Rust Clippy)
    • MRE : Manual Rem Euclid (Rust Clippy)
    • MRP : Manual Range Patterns (Rust Clippy)
    • MSB : Match Single Binding (Rust Clippy)
    • MSO : Manual Split Once (Rust Clippy)
    • MSSC : Manual Slice Size Calculation (Rust Clippy)
    • MSTRIP : Manual Strip (Rust Clippy)
    • MSWAP : Manual Swap (Rust Clippy)
    • MUO : Manual Unwrap or (Rust Clippy)
    • NAST : Needless Arbitrary Self Type (Rust Clippy)
    • NBA : Needless Bool Assign (Rust Clippy)
    • NBOOL : Needless Bool (Rust Clippy)
    • NBR : Needless Borrowed Reference (Rust Clippy)
    • NCOOPO : Neg Cmp Op on Partial Ord (Rust Clippy)
    • NE : No Effect (Rust Clippy)
    • NI : Needless If (Rust Clippy)
    • NL : Needless Lifetimes (Rust Clippy)
    • NM : Needless Match (Rust Clippy)
    • NMBOOL : Nonminimal Bool (Rust Clippy)
    • NOAD : Needless Option As Deref (Rust Clippy)
    • NOT : Needless Option Take (Rust Clippy)
    • NQM : Needless Question Mark (Rust Clippy)
    • NS : Needless Splitn (Rust Clippy)
    • NU : Needless Update (Rust Clippy)
    • OARD : Option As Ref Deref (Rust Clippy)
    • OCC : Overflow Check Conditional (Rust Clippy)
    • OFM : Option Filter Map (Rust Clippy)
    • OMUF : Option Map Unit Fn (Rust Clippy)
    • OTU : Or Then Unwrap (Rust Clippy)
    • OUIR : Only Used in Recursion (Rust Clippy)
    • PNI : Partialeq Ne Impl (Rust Clippy)
    • POWC : Ptr Offset With Cast (Rust Clippy)
    • PRECEDENCE : Precedence (Rust Clippy)
    • RAB : Redundant Async Block (Rust Clippy)
    • RAI : Reserve After Initialization (Rust Clippy)
    • RARP : Redundant at Rest Pattern (Rust Clippy)
    • RAS : Redundant As Str (Rust Clippy)
    • RCC : Redundant Closure Call (Rust Clippy)
    • RG : Redundant Guards (Rust Clippy)
    • RMUF : Result Map Unit Fn (Rust Clippy)
    • RO : Repeat Once (Rust Clippy)
    • RS : Redundant Slicing (Rust Clippy)
    • RZWL : Range Zip With Len (Rust Clippy)
    • SCS : Short Circuit Statement (Rust Clippy)
    • SEL : Single Element Loop (Rust Clippy)
    • SFC : Seek From Current (Rust Clippy)
    • SFUAB : String From Utf8 As Bytes (Rust Clippy)
    • SIS : Search Is Some (Rust Clippy)
    • SOCS : Strlen on C Strings (Rust Clippy)
    • STSIOR : Seek to Start Instead of Rewind (Rust Clippy)
    • SWN : Skip While Next (Rust Clippy)
    • TA : Temporary Assignment (Rust Clippy)
    • TBTS : Transmute Bytes to Str (Rust Clippy)
    • TC : Type Complexity (Rust Clippy)
    • TEAPC : Transmutes Expressible As Ptr Casts (Rust Clippy)
    • TFTI : Transmute Float to Int (Rust Clippy)
    • TITB : Transmute Int to Bool (Rust Clippy)
    • TITC : Transmute Int to Char (Rust Clippy)
    • TITF : Transmute Int to Float (Rust Clippy)
    • TITNZ : Transmute Int to Non Zero (Rust Clippy)
    • TMA : Too Many Arguments (Rust Clippy)
    • TNTB : Transmute Num to Bytes (Rust Clippy)
    • TPTR : Transmute Ptr to Ref (Rust Clippy)
    • UARG : Unit Arg (Rust Clippy)
    • UASREF : Useless Asref (Rust Clippy)
    • UCAST : Unnecessary Cast (Rust Clippy)
    • UCONV : Useless Conversion (Rust Clippy)
    • UF : Useless Format (Rust Clippy)
    • UFLTMAP : Unnecessary Filter Map (Rust Clippy)
    • UFNDMAP : Unnecessary Find Map (Rust Clippy)
    • UFS : Unused Format Specs (Rust Clippy)
    • ULU : Unnecessary Literal Unwrap (Rust Clippy)
    • UMOC : Unnecessary Map on Constructor (Rust Clippy)
    • UO : Unnecessary Operation (Rust Clippy)
    • USB : Unnecessary Sort By (Rust Clippy)
    • UT : Useless Transmute (Rust Clippy)
    • UU : Unnecessary Unwrap (Rust Clippy)
    • UWP : Unneeded Wildcard Pattern (Rust Clippy)
    • VB : Vec Box (Rust Clippy)
    • WIOP : Wildcard in or Patterns (Rust Clippy)
    • WLL : While Let Loop (Rust Clippy)
    • ZDBZ : Zero Divided By Zero (Rust Clippy)
    • ZPL : Zero Prefixed Literal (Rust Clippy)
  • CORRECTNESS
    • AC : Approx Constant (Rust Clippy)
    • AEC : Absurd Extreme Comparisons (Rust Clippy)
    • AS : Almost Swapped (Rust Clippy)
    • AYA : Async Yields Async (Rust Clippy)
    • BBM : Bad Bit Mask (Rust Clippy)
    • CSDS : Cast Slice Different Sizes (Rust Clippy)
    • DHWME : Derived Hash With Manual Eq (Rust Clippy)
    • DOXPO : Derive Ord Xor Partial Ord (Rust Clippy)
    • DS : Deprecated Semver (Rust Clippy)
    • ECUV : Enum Clike Unportable Variant (Rust Clippy)
    • EQOP : Eq Op (Rust Clippy)
    • ERSOP : Erasing Op (Rust Clippy)
    • FAC : Fn Address Comparisons (Rust Clippy)
    • IBM : Ineffective Bit Mask (Rust Clippy)
    • ICHAR : Invisible Characters (Rust Clippy)
    • ICOMP : Impossible Comparisons (Rust Clippy)
    • IFWB : Inline Fn Without Body (Rust Clippy)
    • II : Infinite Iter (Rust Clippy)
    • ILM : If Let Mutex (Rust Clippy)
    • INL : Iter Next Loop (Rust Clippy)
    • INPU : Invalid Null Ptr Usage (Rust Clippy)
    • IR : Invalid Regex (Rust Clippy)
    • ISBZ : Iterator Step By Zero (Rust Clippy)
    • ISC : Ifs Same Cond (Rust Clippy)
    • ISTE : If Same Then Else (Rust Clippy)
    • ISZ : Iter Skip Zero (Rust Clippy)
    • ITSSD : Inherent to String Shadow Display (Rust Clippy)
    • LUL : Let Underscore Lock (Rust Clippy)
    • MFR : Mut From Ref (Rust Clippy)
    • MLS : Mistyped Literal Suffixes (Rust Clippy)
    • MM : Min Max (Rust Clippy)
    • MO : Modulo One (Rust Clippy)
    • MRWU : Mem Replace With Uninit (Rust Clippy)
    • MSCM : Match Str Case Mismatch (Rust Clippy)
    • MTO : Mismatched Target Os (Rust Clippy)
    • NL : Never Loop (Rust Clippy)
    • NOO : Nonsensical Open Options (Rust Clippy)
    • NOUP : Non Octal Unix Permissions (Rust Clippy)
    • NUPAD : Not Unsafe Ptr Arg Deref (Rust Clippy)
    • OCBE : Overly Complex Bool Expr (Rust Clippy)
    • OEU : Option Env Unwrap (Rust Clippy)
    • OOBI : Out of Bounds Indexing (Rust Clippy)
    • PMC : Possible Missing Comma (Rust Clippy)
    • PU : Panicking Unwrap (Rust Clippy)
    • RC : Redundant Comparisons (Rust Clippy)
    • RER : Reversed Empty Ranges (Rust Clippy)
    • RFI : Recursive Format Impl (Rust Clippy)
    • RL : Redundant Locals (Rust Clippy)
    • RLWT : Read Line Without Trim (Rust Clippy)
    • SA : Self Assignment (Rust Clippy)
    • SAM : Serde Api Misuse (Rust Clippy)
    • SOIEC : Size of in Element Count (Rust Clippy)
    • SS : Suspicious Splitn (Rust Clippy)
    • TN : Transmuting Null (Rust Clippy)
    • TNTF : Transmute Null to Fn (Rust Clippy)
    • UA : Useless Attribute (Rust Clippy)
    • UAI : Uninit Assumed Init (Rust Clippy)
    • UC : Unit Cmp (Rust Clippy)
    • UCT : Unsound Collection Transmute (Rust Clippy)
    • UH : Unit Hash (Rust Clippy)
    • UIA : Unused Io Amount (Rust Clippy)
    • UREO : Unit Return Expecting Ord (Rust Clippy)
    • UV : Uninit Vec (Rust Clippy)
    • VAC : Vtable Address Comparisons (Rust Clippy)
    • VRTZ : Vec Resize to Zero (Rust Clippy)
    • WIC : While Immutable Condition (Rust Clippy)
    • WT : Wrong Transmute (Rust Clippy)
    • ZO : Zst Offset (Rust Clippy)
  • DEPRECATED
    • AO : Assign Ops (Rust Clippy)
    • EFS : Extend From Slice (Rust Clippy)
    • FLTMAP : Filter Map (Rust Clippy)
    • FNDMAP : Find Map (Rust Clippy)
    • ILRPM : If Let Redundant Pattern Matching (Rust Clippy)
    • MT : Misaligned Transmute (Rust Clippy)
    • PEVN : Pub Enum Variant Names (Rust Clippy)
    • RC : Replace Consts (Rust Clippy)
    • RM : Regex Macro (Rust Clippy)
    • RSBZ : Range Step By Zero (Rust Clippy)
    • SAE : Should Assert Eq (Rust Clippy)
    • UAMS : Unstable As Mut Slice (Rust Clippy)
    • UAS : Unstable As Slice (Rust Clippy)
    • UC : Unused Collect (Rust Clippy)
    • UVI : Unsafe Vector Initialization (Rust Clippy)
    • WPSC : Wrong Pub Self Convention (Rust Clippy)
  • NURSERY
    • APCM : As Ptr Cast Mut (Rust Clippy)
    • BSC : Branches Sharing Code (Rust Clippy)
    • CC : Cognitive Complexity (Rust Clippy)
    • CINR : Collection Is Never Read (Rust Clippy)
    • CWD : Clear With Drain (Rust Clippy)
    • DAWMC : Debug Assert With Mut Call (Rust Clippy)
    • DPEWE : Derive Partial Eq Without Eq (Rust Clippy)
    • EIL : Equatable If Let (Rust Clippy)
    • ELADC : Empty Line After Doc Comments (Rust Clippy)
    • ELAOA : Empty Line After Outer Attr (Rust Clippy)
    • FIF : Fallible Impl From (Rust Clippy)
    • FNS : Future Not Send (Rust Clippy)
    • IBII : Implied Bounds in Impls (Rust Clippy)
    • IF : Imprecise Flops (Rust Clippy)
    • IOEC : Iter on Empty Collections (Rust Clippy)
    • IOSI : Iter on Single Items (Rust Clippy)
    • IWD : Iter With Drain (Rust Clippy)
    • LSF : Large Stack Frames (Rust Clippy)
    • MC : Manual Clamp (Rust Clippy)
    • MCFF : Missing Const for Fn (Rust Clippy)
    • MI : Mutex Integer (Rust Clippy)
    • NC : Needless Collect (Rust Clippy)
    • NMB : Nonstandard Macro Braces (Rust Clippy)
    • NPBRM : Needless Pass By Ref Mut (Rust Clippy)
    • NSFIST : Non Send Fields in Send Ty (Rust Clippy)
    • OFC : Or Fun Call (Rust Clippy)
    • OILE : Option If Let Else (Rust Clippy)
    • PBPO : Path Buf Push Overwrite (Rust Clippy)
    • RC : Redundant Clone (Rust Clippy)
    • RPC : Redundant Pub Crate (Rust Clippy)
    • RWL : Readonly Write Lock (Rust Clippy)
    • RZBV : Read Zero Byte Vec (Rust Clippy)
    • SDIS : Significant Drop in Scrutinee (Rust Clippy)
    • SDT : Significant Drop Tightening (Rust Clippy)
    • SF : Suboptimal Flops (Rust Clippy)
    • SLAB : String Lit As Bytes (Rust Clippy)
    • SOG : Suspicious Operation Groupings (Rust Clippy)
    • TAC : Tuple Array Conversions (Rust Clippy)
    • TDIB : Trait Duplication in Bounds (Rust Clippy)
    • TEA : Trailing Empty Array (Rust Clippy)
    • TR : Trivial Regex (Rust Clippy)
    • TRIB : Type Repetition in Bounds (Rust Clippy)
    • TUR : Transmute Undefined Repr (Rust Clippy)
    • ULIS : Useless Let If Seq (Rust Clippy)
    • UP : Unused Peekable (Rust Clippy)
    • UR : Unused Rounding (Rust Clippy)
    • US : Use Self (Rust Clippy)
    • USI : Unnecessary Struct Initialization (Rust Clippy)
  • PEDANTIC
    • BAP : Borrow As Ptr (Rust Clippy)
    • BTIWI : Bool to Int With If (Rust Clippy)
    • CC : Checked Conversions (Rust Clippy)
    • CI : Copy Iterator (Rust Clippy)
    • CIOC : Cloned Instead of Copied (Rust Clippy)
    • CL : Cast Lossless (Rust Clippy)
    • CPA : Cast Ptr Alignment (Rust Clippy)
    • CPL : Cast Precision Loss (Rust Clippy)
    • CPT : Cast Possible Truncation (Rust Clippy)
    • CPW : Cast Possible Wrap (Rust Clippy)
    • CSFEC : Case Sensitive File Extension Comparisons (Rust Clippy)
    • CSL : Cast Sign Loss (Rust Clippy)
    • DLWQ : Doc Link With Quotes (Rust Clippy)
    • DM : Doc Markdown (Rust Clippy)
    • DTA : Default Trait Access (Rust Clippy)
    • EDM : Explicit Deref Methods (Rust Clippy)
    • EE : Empty Enum (Rust Clippy)
    • EGU : Enum Glob Use (Rust Clippy)
    • EICOC : Expl Impl Clone on Copy (Rust Clippy)
    • EIIL : Explicit Into Iter Loop (Rust Clippy)
    • EIL : Explicit Iter Loop (Rust Clippy)
    • FC : Float Cmp (Rust Clippy)
    • FIIOC : From Iter Instead of Collect (Rust Clippy)
    • FMN : Filter Map Next (Rust Clippy)
    • FMO : Flat Map Option (Rust Clippy)
    • FPEB : Fn Params Excessive Bools (Rust Clippy)
    • IA : Inline Always (Rust Clippy)
    • IAS : Items After Statements (Rust Clippy)
    • IC : Implicit Clone (Rust Clippy)
    • IH : Implicit Hasher (Rust Clippy)
    • IIWI : Into Iter Without Iter (Rust Clippy)
    • INE : If Not Else (Rust Clippy)
    • INRI : Iter Not Returning Iterator (Rust Clippy)
    • IRS : Index Refutable Slice (Rust Clippy)
    • ISC : Inconsistent Struct Constructor (Rust Clippy)
    • ITS : Inefficient to String (Rust Clippy)
    • IUC : Invalid Upcast Comparisons (Rust Clippy)
    • IUP : Ignored Unit Patterns (Rust Clippy)
    • IWII : Iter Without Into Iter (Rust Clippy)
    • LDG : Large Digit Groups (Rust Clippy)
    • LF : Large Futures (Rust Clippy)
    • LINKEDLIST : Linkedlist (Rust Clippy)
    • LSA : Large Stack Arrays (Rust Clippy)
    • LTPBV : Large Types Passed By Value (Rust Clippy)
    • MA : Manual Assert (Rust Clippy)
    • MB : Match Bool (Rust Clippy)
    • MED : Missing Errors Doc (Rust Clippy)
    • MFID : Missing Fields in Debug (Rust Clippy)
    • MIE : Manual Instant Elapsed (Rust Clippy)
    • MII : Maybe Infinite Iter (Rust Clippy)
    • MLE : Manual Let Else (Rust Clippy)
    • MM : Mut Mut (Rust Clippy)
    • MNR : Module Name Repetitions (Rust Clippy)
    • MOO : Manual Ok or (Rust Clippy)
    • MOVI : Match on Vec Items (Rust Clippy)
    • MPD : Missing Panics Doc (Rust Clippy)
    • MSA : Match Same Arms (Rust Clippy)
    • MSCN : Many Single Char Names (Rust Clippy)
    • MSN : Manual String New (Rust Clippy)
    • MTPO : Mismatching Type Param Order (Rust Clippy)
    • MUC : Must Use Candidate (Rust Clippy)
    • MUI : Macro Use Imports (Rust Clippy)
    • MUO : Map Unwrap or (Rust Clippy)
    • MWEA : Match Wild Err Arm (Rust Clippy)
    • MWFSV : Match Wildcard for Single Variants (Rust Clippy)
    • NB : Naive Bytecount (Rust Clippy)
    • NBB : Needless Bitwise Bool (Rust Clippy)
    • NC : Needless Continue (Rust Clippy)
    • NEUB : No Effect Underscore Binding (Rust Clippy)
    • NFE : Needless for Each (Rust Clippy)
    • NMWRA : No Mangle With Rust Abi (Rust Clippy)
    • NPBV : Needless Pass By Value (Rust Clippy)
    • NRSH : Needless Raw String Hashes (Rust Clippy)
    • OO : Option Option (Rust Clippy)
    • PAP : Ptr As Ptr (Rust Clippy)
    • PCC : Ptr Cast Constness (Rust Clippy)
    • RBTR : Ref Binding to Reference (Rust Clippy)
    • RCFMC : Redundant Closure for Method Calls (Rust Clippy)
    • RE : Redundant Else (Rust Clippy)
    • RMO : Range Minus One (Rust Clippy)
    • ROR : Ref Option Ref (Rust Clippy)
    • RPO : Range Plus One (Rust Clippy)
    • RSNMU : Return Self Not Must Use (Rust Clippy)
    • SAA : String Add Assign (Rust Clippy)
    • SEB : Struct Excessive Bools (Rust Clippy)
    • SFIIC : Same Functions in If Condition (Rust Clippy)
    • SFN : Struct Field Names (Rust Clippy)
    • SINR : Semicolon If Nothing Returned (Rust Clippy)
    • SME : Single Match Else (Rust Clippy)
    • SN : Similar Names (Rust Clippy)
    • SPWE : Should Panic Without Expect (Rust Clippy)
    • SSP : Stable Sort Primitive (Rust Clippy)
    • TCPBR : Trivially Copy Pass By Ref (Rust Clippy)
    • TML : Too Many Lines (Rust Clippy)
    • TPTP : Transmute Ptr to Ptr (Rust Clippy)
    • UA : Unused Async (Rust Clippy)
    • UBR : Unnecessary Box Returns (Rust Clippy)
    • UDD : Unsafe Derive Deserialize (Rust Clippy)
    • UDS : Unchecked Duration Subtraction (Rust Clippy)
    • UFA : Uninlined Format Args (Rust Clippy)
    • UJ : Unnecessary Join (Rust Clippy)
    • UL : Unreadable Literal (Rust Clippy)
    • UNN : Unicode Not Nfc (Rust Clippy)
    • UOP : Unnested or Patterns (Rust Clippy)
    • US : Unused Self (Rust Clippy)
    • UUB : Used Underscore Binding (Rust Clippy)
    • UW : Unnecessary Wraps (Rust Clippy)
    • VBM : Verbose Bit Mask (Rust Clippy)
    • WI : Wildcard Imports (Rust Clippy)
    • ZSMV : Zero Sized Map Values (Rust Clippy)
  • PERF
    • BC : Box Collection (Rust Clippy)
    • BD : Box Default (Rust Clippy)
    • BL : Boxed Local (Rust Clippy)
    • CO : Cmp Owned (Rust Clippy)
    • CSR : Collapsible Str Replace (Rust Clippy)
    • DC : Drain Collect (Rust Clippy)
    • EFC : Expect Fun Call (Rust Clippy)
    • EWD : Extend With Drain (Rust Clippy)
    • FC : Format Collect (Rust Clippy)
    • FIFA : Format in Format Args (Rust Clippy)
    • IN : Iter Nth (Rust Clippy)
    • IOC : Iter Overeager Cloned (Rust Clippy)
    • LCA : Large Const Arrays (Rust Clippy)
    • LEV : Large Enum Variant (Rust Clippy)
    • ME : Map Entry (Rust Clippy)
    • MM : Manual Memcpy (Rust Clippy)
    • MR : Manual Retain (Rust Clippy)
    • MSL : Missing Spin Loop (Rust Clippy)
    • MSR : Manual Str Repeat (Rust Clippy)
    • MTF : Manual Try Fold (Rust Clippy)
    • RA : Redundant Allocation (Rust Clippy)
    • RLE : Result Large Err (Rust Clippy)
    • SCP : Single Char Pattern (Rust Clippy)
    • SVI : Slow Vector Initialization (Rust Clippy)
    • TSIFA : To String in Format Args (Rust Clippy)
    • UTO : Unnecessary to Owned (Rust Clippy)
    • UV : Useless Vec (Rust Clippy)
    • VITP : Vec Init Then Push (Rust Clippy)
    • WCW : Waker Clone Wake (Rust Clippy)
  • RESTRICTION
    • AA : Allow Attributes (Rust Clippy)
    • AAWR : Allow Attributes Without Reason (Rust Clippy)
    • AC : As Conversions (Rust Clippy)
    • AIOC : Alloc Instead of Core (Rust Clippy)
    • AORS : Assertions on Result States (Rust Clippy)
    • AP : Absolute Paths (Rust Clippy)
    • ASE : Arithmetic Side Effects (Rust Clippy)
    • AU : As Underscore (Rust Clippy)
    • BEB : Big Endian Bytes (Rust Clippy)
    • CD : Create Dir (Rust Clippy)
    • CORP : Clone on Ref Ptr (Rust Clippy)
    • DBS : Deref By Slicing (Rust Clippy)
    • DLR : Decimal Literal Representation (Rust Clippy)
    • DM : Dbg Macro (Rust Clippy)
    • DNF : Default Numeric Fallback (Rust Clippy)
    • DSI : Disallowed Script Idents (Rust Clippy)
    • DUR : Default Union Representation (Rust Clippy)
    • ED : Empty Drop (Rust Clippy)
    • EE : Exhaustive Enums (Rust Clippy)
    • EIE : Error Impl Error (Rust Clippy)
    • EIWE : Else If Without Else (Rust Clippy)
    • ES : Exhaustive Structs (Rust Clippy)
    • ESWB : Empty Structs With Brackets (Rust Clippy)
    • EU : Expect Used (Rust Clippy)
    • EXIT : Exit (Rust Clippy)
    • FA : Float Arithmetic (Rust Clippy)
    • FCC : Float Cmp Const (Rust Clippy)
    • FIF : Filetype Is File (Rust Clippy)
    • FPS : Format Push String (Rust Clippy)
    • FTNCA : Fn to Numeric Cast Any (Rust Clippy)
    • GU : Get Unwrap (Rust Clippy)
    • HEB : Host Endian Bytes (Rust Clippy)
    • IAXAS : Inline Asm X86 Att Syntax (Rust Clippy)
    • IAXIS : Inline Asm X86 Intel Syntax (Rust Clippy)
    • ID : Integer Division (Rust Clippy)
    • IR : Implicit Return (Rust Clippy)
    • IS : Indexing Slicing (Rust Clippy)
    • ITIP : Impl Trait in Params (Rust Clippy)
    • ITSEN : If Then Some Else None (Rust Clippy)
    • LEB : Little Endian Bytes (Rust Clippy)
    • LFL : Lossy Float Literal (Rust Clippy)
    • LIF : Large Include File (Rust Clippy)
    • LUMU : Let Underscore Must Use (Rust Clippy)
    • LUU : Let Underscore Untyped (Rust Clippy)
    • MAFI : Missing Asserts for Indexing (Rust Clippy)
    • MAM : Missing Assert Message (Rust Clippy)
    • MDIPI : Missing Docs in Private Items (Rust Clippy)
    • MEI : Map Err Ignore (Rust Clippy)
    • MF : Mem Forget (Rust Clippy)
    • MIC : Min Ident Chars (Rust Clippy)
    • MII : Multiple Inherent Impl (Rust Clippy)
    • MIIPI : Missing Inline in Public Items (Rust Clippy)
    • MMF : Mod Module Files (Rust Clippy)
    • MODA : Modulo Arithmetic (Rust Clippy)
    • MRWIE : Mixed Read Write in Expression (Rust Clippy)
    • MTM : Missing Trait Methods (Rust Clippy)
    • MUOPB : Multiple Unsafe Ops Per Block (Rust Clippy)
    • MUTATOM : Mutex Atomic (Rust Clippy)
    • NAL : Non Ascii Literal (Rust Clippy)
    • NRS : Needless Raw Strings (Rust Clippy)
    • PANIC : Panic (Rust Clippy)
    • PIRF : Panic in Result Fn (Rust Clippy)
    • PPF : Partial Pub Fields (Rust Clippy)
    • PSTDERR : Print Stderr (Rust Clippy)
    • PSTDOUT : Print Stdout (Rust Clippy)
    • PTM : Pattern Type Mismatch (Rust Clippy)
    • PU : Pub Use (Rust Clippy)
    • PUBWOSH : Pub Without Shorthand (Rust Clippy)
    • PUBWSH : Pub With Shorthand (Rust Clippy)
    • QMU : Question Mark Used (Rust Clippy)
    • RB : Rc Buffer (Rust Clippy)
    • RM : Rc Mutex (Rust Clippy)
    • RP : Ref Patterns (Rust Clippy)
    • RPIFBS : Rest Pat in Fully Bound Structs (Rust Clippy)
    • RTA : Redundant Type Annotations (Rust Clippy)
    • SA : String Add (Rust Clippy)
    • SCF : Single Call Fn (Rust Clippy)
    • SCLN : Single Char Lifetime Names (Rust Clippy)
    • SHDWS : Shadow Same (Rust Clippy)
    • SIB : Semicolon Inside Block (Rust Clippy)
    • SIOA : Std Instead of Alloc (Rust Clippy)
    • SIOC : Std Instead of Core (Rust Clippy)
    • SLCA : String Lit Chars Any (Rust Clippy)
    • SLS : Separated Literal Suffix (Rust Clippy)
    • SNM : Same Name Method (Rust Clippy)
    • SNMF : Self Named Module Files (Rust Clippy)
    • SOB : Semicolon Outside Block (Rust Clippy)
    • SR : Shadow Reuse (Rust Clippy)
    • STR2STRG : Str to String (Rust Clippy)
    • STRG2STRG : String to String (Rust Clippy)
    • STRS : String Slice (Rust Clippy)
    • SU : Shadow Unrelated (Rust Clippy)
    • SXUAP : Suspicious Xor Used As Pow (Rust Clippy)
    • TE : Try Err (Rust Clippy)
    • TODO : Todo (Rust Clippy)
    • TOTM : Tests Outside Test Module (Rust Clippy)
    • UD : Use Debug (Rust Clippy)
    • UFP : Unneeded Field Pattern (Rust Clippy)
    • UIMPL : Unimplemented (Rust Clippy)
    • UIR : Unwrap in Result (Rust Clippy)
    • ULS : Unseparated Literal Suffix (Rust Clippy)
    • UNRCH : Unreachable (Rust Clippy)
    • USC : Unnecessary Safety Comment (Rust Clippy)
    • USD : Unnecessary Safety Doc (Rust Clippy)
    • USI : Unnecessary Self Imports (Rust Clippy)
    • UU : Unwrap Used (Rust Clippy)
    • UUB : Undocumented Unsafe Blocks (Rust Clippy)
    • VFR : Verbose File Reads (Rust Clippy)
    • WEMA : Wildcard Enum Match Arm (Rust Clippy)
  • STYLE
    • AOC : Assertions on Constants (Rust Clippy)
    • AOP : Assign Op Pattern (Rust Clippy)
    • BAC : Bool Assert Comparison (Rust Clippy)
    • BIIC : Blocks in If Conditions (Rust Clippy)
    • BIMC : Borrow Interior Mutable Const (Rust Clippy)
    • BN : Bytes Nth (Rust Clippy)
    • BTS : Builtin Type Shadow (Rust Clippy)
    • CC : Comparison Chain (Rust Clippy)
    • CEI : Collapsible Else If (Rust Clippy)
    • CI : Collapsible If (Rust Clippy)
    • CLC : Chars Last Cmp (Rust Clippy)
    • CM : Collapsible Match (Rust Clippy)
    • CN : Cmp Null (Rust Clippy)
    • CNC : Chars Next Cmp (Rust Clippy)
    • CTE : Comparison to Empty (Rust Clippy)
    • DIMC : Declare Interior Mutable Const (Rust Clippy)
    • DIOIE : Default Instead of Iter Empty (Rust Clippy)
    • DMCR : Disallowed Macros (Rust Clippy)
    • DMETH : Disallowed Methods (Rust Clippy)
    • DMU : Double Must Use (Rust Clippy)
    • DNAM : Disallowed Names (Rust Clippy)
    • DNEG : Double Neg (Rust Clippy)
    • DT : Disallowed Types (Rust Clippy)
    • DUA : Duplicate Underscore Argument (Rust Clippy)
    • EE : Err Expect (Rust Clippy)
    • EP : Excessive Precision (Rust Clippy)
    • EVN : Enum Variant Names (Rust Clippy)
    • FKM : For Kv Map (Rust Clippy)
    • FMBT : Filter Map Bool Then (Rust Clippy)
    • FOI : From Over Into (Rust Clippy)
    • FRWD : Field Reassign With Default (Rust Clippy)
    • FSR10 : From Str Radix 10 (Rust Clippy)
    • FTNC : Fn to Numeric Cast (Rust Clippy)
    • FTNCWT : Fn to Numeric Cast With Truncation (Rust Clippy)
    • GF : Get First (Rust Clippy)
    • IATM : Items After Test Module (Rust Clippy)
    • ICC : Iter Cloned Collect (Rust Clippy)
    • IDAR : Is Digit Ascii Radix (Rust Clippy)
    • IDG : Inconsistent Digit Grouping (Rust Clippy)
    • IDM : Infallible Destructuring Match (Rust Clippy)
    • IIOR : Into Iter on Ref (Rust Clippy)
    • INF : Init Numbered Fields (Rust Clippy)
    • INS : Iter Next Slice (Rust Clippy)
    • INZ : Iter Nth Zero (Rust Clippy)
    • ISA : Implicit Saturating Add (Rust Clippy)
    • ISN : Iter Skip Next (Rust Clippy)
    • ISS : Implicit Saturating Sub (Rust Clippy)
    • ITS : Inherent to String (Rust Clippy)
    • JUAD : Just Underscores and Digits (Rust Clippy)
    • LAR : Let and Return (Rust Clippy)
    • LUV : Let Unit Value (Rust Clippy)
    • LWIE : Len Without Is Empty (Rust Clippy)
    • LZ : Len Zero (Rust Clippy)
    • MAF : Manual Async Fn (Rust Clippy)
    • MB : Manual Bits (Rust Clippy)
    • MC : Map Clone (Rust Clippy)
    • MCHL : Mixed Case Hex Literals (Rust Clippy)
    • MCRU : Map Collect Result Unit (Rust Clippy)
    • MEIR : Missing Enforced Import Renames (Rust Clippy)
    • MI : Module Inception (Rust Clippy)
    • MIAC : Manual Is Ascii Check (Rust Clippy)
    • MIF : Manual Is Finite (Rust Clippy)
    • MII : Manual Is Infinite (Rust Clippy)
    • MLMM : Match Like Matches Macro (Rust Clippy)
    • MM : Manual Map (Rust Clippy)
    • MML : Mut Mutex Lock (Rust Clippy)
    • MNB : Manual Next Back (Rust Clippy)
    • MNE : Manual Non Exhaustive (Rust Clippy)
    • MOA : Match Overlapping Arm (Rust Clippy)
    • MR : Main Recursion (Rust Clippy)
    • MRC : Manual Range Contains (Rust Clippy)
    • MRO : Match Result Ok (Rust Clippy)
    • MROWN : Mem Replace Option With None (Rust Clippy)
    • MRP : Match Ref Pats (Rust Clippy)
    • MRWD : Mem Replace With Default (Rust Clippy)
    • MSA : Manual Saturating Arithmetic (Rust Clippy)
    • MSD : Missing Safety Doc (Rust Clippy)
    • MUU : Must Use Unit (Rust Clippy)
    • MWLS : Manual While Let Some (Rust Clippy)
    • NB : Needless Borrow (Rust Clippy)
    • NBFGA : Needless Borrows for Generic Args (Rust Clippy)
    • NDM : Needless Doctest Main (Rust Clippy)
    • NE : Needless Else (Rust Clippy)
    • NLI : Needless Late Init (Rust Clippy)
    • NM : Neg Multiply (Rust Clippy)
    • NMC : Non Minimal Cfg (Rust Clippy)
    • NPORL : Needless Parens on Range Literals (Rust Clippy)
    • NPS : Needless Pub Self (Rust Clippy)
    • NR : Needless Return (Rust Clippy)
    • NRL : Needless Range Loop (Rust Clippy)
    • NRNS : New Ret No Self (Rust Clippy)
    • NRWQM : Needless Return With Question Mark (Rust Clippy)
    • NWD : New Without Default (Rust Clippy)
    • OE : Ok Expect (Rust Clippy)
    • OIE : Obfuscated If Else (Rust Clippy)
    • OMON : Option Map or None (Rust Clippy)
    • OR : Op Ref (Rust Clippy)
    • PA : Ptr Arg (Rust Clippy)
    • PE : Ptr Eq (Rust Clippy)
    • PES : Println Empty String (Rust Clippy)
    • PL : Print Literal (Rust Clippy)
    • PTN : Partialeq to None (Rust Clippy)
    • PWN : Print With Newline (Rust Clippy)
    • QM : Question Mark (Rust Clippy)
    • RC : Redundant Closure (Rust Clippy)
    • RFN : Redundant Field Names (Rust Clippy)
    • RMOIO : Result Map or Into Option (Rust Clippy)
    • RP : Redundant Pattern (Rust Clippy)
    • RPM : Redundant Pattern Matching (Rust Clippy)
    • RSL : Redundant Static Lifetimes (Rust Clippy)
    • RUE : Result Unit Err (Rust Clippy)
    • SCAS : Single Char Add Str (Rust Clippy)
    • SCPI : Single Component Path Imports (Rust Clippy)
    • SEC : String Extend Chars (Rust Clippy)
    • SIP : Same Item Push (Rust Clippy)
    • SIT : Should Implement Trait (Rust Clippy)
    • SM : Single Match (Rust Clippy)
    • SNC : Self Named Constructors (Rust Clippy)
    • TDIS : To Digit Is Some (Rust Clippy)
    • TIDC : Tabs in Doc Comments (Rust Clippy)
    • TRA : Toplevel Ref Arg (Rust Clippy)
    • TSW : Trim Split Whitespace (Rust Clippy)
    • UBG : Unusual Byte Groupings (Rust Clippy)
    • UCA : Upper Case Acronyms (Rust Clippy)
    • UEI : Unused Enumerate Index (Rust Clippy)
    • UF : Unnecessary Fold (Rust Clippy)
    • UFC : Unnecessary Fallible Conversions (Rust Clippy)
    • ULE : Unnecessary Lazy Evaluations (Rust Clippy)
    • UMP : Unnecessary Mut Passed (Rust Clippy)
    • UOD : Unwrap or Default (Rust Clippy)
    • UOES : Unnecessary Owned Empty Strings (Rust Clippy)
    • URFN : Unsafe Removed From Name (Rust Clippy)
    • UU : Unused Unit (Rust Clippy)
    • WES : Writeln Empty String (Rust Clippy)
    • WL : Write Literal (Rust Clippy)
    • WLOI : While Let on Iterator (Rust Clippy)
    • WSC : Wrong Self Convention (Rust Clippy)
    • WWN : Write With Newline (Rust Clippy)
    • ZP : Zero Ptr (Rust Clippy)
  • SUSPICIOUS
    • ACR : Almost Complete Range (Rust Clippy)
    • AHIT : Await Holding Invalid Type (Rust Clippy)
    • AHL : Await Holding Lock (Rust Clippy)
    • AHRR : Await Holding Refcell Ref (Rust Clippy)
    • AWNSS : Arc With Non Send Sync (Rust Clippy)
    • BCRL : Blanket Clippy Restriction Lints (Rust Clippy)
    • CATU : Cast Abs to Unsigned (Rust Clippy)
    • CEC : Cast Enum Constructor (Rust Clippy)
    • CET : Cast Enum Truncation (Rust Clippy)
    • CIMD : Crate in Macro Def (Rust Clippy)
    • CNTI : Cast Nan to Int (Rust Clippy)
    • CSFRP : Cast Slice From Raw Parts (Rust Clippy)
    • DM : Duplicate Mod (Rust Clippy)
    • DND : Drop Non Drop (Rust Clippy)
    • EL : Empty Loop (Rust Clippy)
    • FEWA : Float Equality Without Abs (Rust Clippy)
    • FFS : Four Forward Slashes (Rust Clippy)
    • FND : Forget Non Drop (Rust Clippy)
    • FRWVP : From Raw With Void Ptr (Rust Clippy)
    • IOOB : Iter Out of Bounds (Rust Clippy)
    • LFMO : Lines Filter Map Ok (Rust Clippy)
    • LUF : Let Underscore Future (Rust Clippy)
    • MA : Multi Assignments (Rust Clippy)
    • MAO : Misrefactored Assign Op (Rust Clippy)
    • MG : Misnamed Getters (Rust Clippy)
    • MKT : Mutable Key Type (Rust Clippy)
    • MMC : Maybe Misused Cfg (Rust Clippy)
    • MRB : Mut Range Bound (Rust Clippy)
    • NCCI : Non Canonical Clone Impl (Rust Clippy)
    • NCPOI : Non Canonical Partial Ord Impl (Rust Clippy)
    • NER : No Effect Replace (Rust Clippy)
    • OE : Octal Escapes (Rust Clippy)
    • PEWE : Path Ends With Ext (Rust Clippy)
    • PIFI : Print in Format Impl (Rust Clippy)
    • PSRF : Permissions Set Readonly False (Rust Clippy)
    • RCIVI : Rc Clone in Vec Init (Rust Clippy)
    • SAF : Suspicious Assignment Formatting (Rust Clippy)
    • SAI : Suspicious Arithmetic Impl (Rust Clippy)
    • SCAS : Suspicious Command Arg Space (Rust Clippy)
    • SDC : Suspicious Doc Comments (Rust Clippy)
    • SEF : Suspicious Else Formatting (Rust Clippy)
    • SM : Suspicious Map (Rust Clippy)
    • SOAI : Suspicious Op Assign Impl (Rust Clippy)
    • SOR : Size of Ref (Rust Clippy)
    • SPTR : Swap Ptr to Ref (Rust Clippy)
    • SRIVI : Single Range in Vec Init (Rust Clippy)
    • STO : Suspicious to Owned (Rust Clippy)
    • SUOF : Suspicious Unary Op Formatting (Rust Clippy)
    • TIOB : Type Id on Box (Rust Clippy)
• TS : TypeScript Warning Classes
  • LAYOUT
    • BLKSP : Block Spacing (TS-ESLint)
    • BRSTYLE : Brace Style (TS-ESLint)
    • CD : Comma Dangle (TS-ESLint)
    • CS : Comma Spacing (TS-ESLint)
    • FCS : Func Call Spacing (TS-ESLint)
    • INDENT : Indent (TS-ESLint)
    • KEYSP : Key Spacing (TS-ESLint)
    • KWDSP : Keyword Spacing (TS-ESLint)
    • LAC : Lines Around Comment (TS-ESLint)
    • LBCM : Lines Between Class Members (TS-ESLint)
    • MDS : Member Delimiter Style (TS-ESLint)
    • NEP : No Extra Parens (TS-ESLint)
    • OCS : Object Curly Spacing (TS-ESLint)
    • PLBS : Padding Line Between Statements (TS-ESLint)
    • QUOTES : Quotes (TS-ESLint)
    • SBB : Space Before Blocks (TS-ESLint)
    • SBFP : Space Before Function Paren (TS-ESLint)
    • SEMI : Semi (TS-ESLint)
    • SIO : Space Infix Ops (TS-ESLint)
    • TAS : Type Annotation Spacing (TS-ESLint)
  • PROBLEM
    • AT : Await Thenable (TS-ESLint)
    • BTC : Ban Ts Comment (TS-ESLint)
    • CLPS : Class Literal Property Style (TS-ESLint)
    • EFRT : Explicit Function Return Type (TS-ESLint)
    • EMA : Explicit Member Accessibility (TS-ESLint)
    • EMBT : Explicit Module Boundary Types (TS-ESLint)
    • NAD : No Array Delete (TS-ESLint)
    • NCNNA : No Confusing Non Null Assertion (TS-ESLint)
    • NCVE : No Confusing Void Expression (TS-ESLint)
    • NDCM : No Dupe Class Members (TS-ESLint)
    • NDEV : No Duplicate Enum Values (TS-ESLint)
    • NENNA : No Extra Non Null Assertion (TS-ESLint)
    • NFIA : No for in Array (TS-ESLint)
    • NFP : No Floating Promises (TS-ESLint)
    • NITSE : No Import Type Side Effects (TS-ESLint)
    • NIVT : No Invalid Void Type (TS-ESLint)
    • NLOP : No Loss of Precision (TS-ESLint)
    • NME : No Mixed Enums (TS-ESLint)
    • NMN : No Misused New (TS-ESLint)
    • NMP : No Misused Promises (TS-ESLint)
    • NNNA : No Non Null Assertion (TS-ESLint)
    • NNNANC : No Non Null Asserted Nullish Coalescing (TS-ESLint)
    • NNNAOC : No Non Null Asserted Optional Chain (TS-ESLint)
    • NRI : No Require Imports (TS-ESLint)
    • NTL : No Throw Literal (TS-ESLint)
    • NUARG : No Unsafe Argument (TS-ESLint)
    • NUASGN : No Unsafe Assignment (TS-ESLint)
    • NUBD : No Use Before Define (TS-ESLint)
    • NUCALL : No Unsafe Call (TS-ESLint)
    • NUCONS : No Useless Constructor (TS-ESLint)
    • NUDM : No Unsafe Declaration Merging (TS-ESLint)
    • NUMA : No Unsafe Member Access (TS-ESLint)
    • NUR : No Unsafe Return (TS-ESLint)
    • NUUM : No Unsafe Unary Minus (TS-ESLint)
    • NUV : No Unused Vars (TS-ESLint)
    • NVR : No Var Requires (TS-ESLint)
    • PP : Parameter Properties (TS-ESLint)
    • PRTP : Prefer Reduce Type Parameter (TS-ESLint)
    • PTEE : Prefer Ts Expect Error (TS-ESLint)
    • RA : Return Await (TS-ESLint)
    • RASC : Require Array Sort Compare (TS-ESLint)
    • RPO : Restrict Plus Operands (TS-ESLint)
    • RTE : Restrict Template Expressions (TS-ESLint)
    • UM : Unbound Method (TS-ESLint)
  • SUGGESTION
    • AOS : Adjacent Overload Signatures (TS-ESLint)
    • AT : Array Type (TS-ESLint)
    • BT : Ban Types (TS-ESLint)
    • BTC : Ban Tslint Comment (TS-ESLint)
    • CGC : Consistent Generic Constructors (TS-ESLint)
    • CIOS : Consistent Indexed Object Style (TS-ESLint)
    • CMUT : Class Methods Use This (TS-ESLint)
    • CTA : Consistent Type Assertions (TS-ESLint)
    • CTD : Consistent Type Definitions (TS-ESLint)
    • CTE : Consistent Type Exports (TS-ESLint)
    • CTI : Consistent Type Imports (TS-ESLint)
    • DN : Dot Notation (TS-ESLint)
    • DPL : Default Param Last (TS-ESLint)
    • ID : Init Declarations (TS-ESLint)
    • MO : Member Ordering (TS-ESLint)
    • MP : Max Params (TS-ESLint)
    • MSS : Method Signature Style (TS-ESLint)
    • NAC : No Array Constructor (TS-ESLint)
    • NBTS : No Base to String (TS-ESLint)
    • NC : Naming Convention (TS-ESLint)
    • NDD : No Dynamic Delete (TS-ESLint)
    • NDTC : No Duplicate Type Constituents (TS-ESLint)
    • NEA : No Explicit Any (TS-ESLint)
    • NEC : No Extraneous Class (TS-ESLint)
    • NEF : No Empty Function (TS-ESLint)
    • NEI : No Empty Interface (TS-ESLint)
    • NES : No Extra Semi (TS-ESLint)
    • NIE : No Implied Eval (TS-ESLint)
    • NINFT : No Inferrable Types (TS-ESLint)
    • NINVTH : No Invalid This (TS-ESLint)
    • NLF : No Loop Func (TS-ESLint)
    • NMN : No Magic Numbers (TS-ESLint)
    • NMVO : No Meaningless Void Operator (TS-ESLint)
    • NN : No Namespace (TS-ESLint)
    • NNTAS : Non Nullable Type Assertion Style (TS-ESLint)
    • NR : No Redeclare (TS-ESLint)
    • NRI : No Restricted Imports (TS-ESLint)
    • NRTC : No Redundant Type Constituents (TS-ESLint)
    • NS : No Shadow (TS-ESLint)
    • NTHA : No This Alias (TS-ESLint)
    • NTYPEA : No Type Alias (TS-ESLint)
    • NUBLC : No Unnecessary Boolean Literal Compare (TS-ESLint)
    • NUC : No Unnecessary Condition (TS-ESLint)
    • NUE : No Unused Expressions (TS-ESLint)
    • NUEC : No Unsafe Enum Comparison (TS-ESLint)
    • NUEE : No Useless Empty Export (TS-ESLint)
    • NUQ : No Unnecessary Qualifier (TS-ESLint)
    • NUTARG : No Unnecessary Type Arguments (TS-ESLint)
    • NUTASRT : No Unnecessary Type Assertion (TS-ESLint)
    • NUTC : No Unnecessary Type Constraint (TS-ESLint)
    • NUTL : No Useless Template Literals (TS-ESLint)
    • PAC : Prefer As Const (TS-ESLint)
    • PD : Prefer Destructuring (TS-ESLint)
    • PEI : Prefer Enum Initializers (TS-ESLint)
    • PF : Prefer Find (TS-ESLint)
    • PFA : Promise Function Async (TS-ESLint)
    • PFO : Prefer for of (TS-ESLint)
    • PFT : Prefer Function Type (TS-ESLint)
    • PI : Prefer Includes (TS-ESLint)
    • PLEM : Prefer Literal Enum Member (TS-ESLint)
    • PNC : Prefer Nullish Coalescing (TS-ESLint)
    • PNK : Prefer Namespace Keyword (TS-ESLint)
    • POC : Prefer Optional Chain (TS-ESLint)
    • PPRE : Prefer Promise Reject Errors (TS-ESLint)
    • PR : Prefer Readonly (TS-ESLint)
    • PRE : Prefer Regexp Exec (TS-ESLint)
    • PRPT : Prefer Readonly Parameter Types (TS-ESLint)
    • PRTT : Prefer Return This Type (TS-ESLint)
    • PSSEW : Prefer String Starts Ends With (TS-ESLint)
    • RA : Require Await (TS-ESLint)
    • SBE : Strict Boolean Expressions (TS-ESLint)
    • SEC : Switch Exhaustiveness Check (TS-ESLint)
    • STC : Sort Type Constituents (TS-ESLint)
    • TSR : Triple Slash Reference (TS-ESLint)
    • TYPEDEF : Typedef (TS-ESLint)
    • US : Unified Signatures (TS-ESLint)