CodeSonar Warning Class Significance

JavaScript is not currently enabled, but is required for full CodeSonar manual search and browse functionality.

If you are viewing this file in your hub's Web GUI, enable JavaScript in your browser: you will also need it for GUI functionality.

If you opened this file directly from disk, your browser may be directly suppressing JavaScript functionality: certain browsers perform this suppression on local files (but not files delivered by web servers) for security reasons.

If you access the manual through the hub's Web GUI, the functionality will not be suppressed because the hub is a web server.
Alternatively, your browser may allow you to explicitly disable the security setting that suppresses functionality. See the CodeSonar FAQ for more information.

CodeSonar^® 9.2p0

CONFIDENTIAL

CodeSecure Inc

CodeSonar Warning Class Significance

Every warning class is associated with a Significance value that provides a high-level indication of the purpose of the class and the likely severity of vulnerabilities of that class.

About Significance
Using Significance
Warning Classes By Significance

About Significance

Every warning class is associated with one of the following Significance values: security, reliability, redundancy, style, diagnostic. Significance provides a high level indication of the purpose of the class.

Significance is also broadly correlated with the severity of a particular class of warning. For example, most users will consider a code vulnerability that can lead to a security problem to be more severe than a coding style issue. The available Significance values are shown in the table below in order of severity (most-severe first).

Significance Value	Description
security	A security vulnerability.
reliability	A code correctness issue.
redundancy	Redundant code; may indicate a logic error.
style	A violation of one or more coding style guidelines.
diagnostic	The class is purely informative: warnings do not indicate vulnerabilities, they indicate the locations of events or artifacts of interest.

Using Significance

Significance is available in the following contexts.

Web GUI: Display	All tables of warning classes (Analysis:Warnings, Warning Search Results, Warning Cluster) have a Significance column. By default, this column is visible.
Web GUI: Search	Significance is searchable: The warning search language has a significance field-name option. Full-text search (in the warnings domain) includes the significance field. The Advanced Search: Warnings tab includes functionality for selecting significance values of interest.
Creating Custom Warning Classes	All mechanisms for creating a custom warning class require you to specify a Significance value for the new class.
CodeSonar Manual	Significance values for built-in classes are shown in the tables below. The documentation pages for individual warning classes also note the corresponding Significance values.

Warning Classes By Significance

The following tables show all built-in CodeSonar warning classes, grouped by Significance.

Significance: C/C++, Ada, Java, and C# warning classes
Significance: Go, Kotlin, Python, Rust, JavaScript, and TypeScript warning classes

Significance: C/C++, Ada, Java, and C# warning classes

diagnostic
redundancy
reliability
security
style

Significance	Warning Classes
Significance	C/C++	Ada	Java	C#
diagnostic	Essential Type Diagnostic Signal Handler Entry Point Thread Entry Point Unexercised Call Unexercised Computation Unexercised Conditional Unexercised Control Flow Unexercised Data Flow	Call Too Complex (Ada) Dead Code Continues (Ada) Module Analyzed (Ada) Module Not Analyzed (Ada) Subprogram Incompletely Analyzed (Ada) Subprogram Not Analyzed (Ada) Subprogram Not Available (Ada)
redundancy	Empty Branch Statement Empty for Statement Empty if Statement Empty switch Statement Empty while Statement Explicit Zero Alignment Free Null Pointer Masked by Default Handler Masked by Handler Missing Non-default Association in C Generic Redundant Condition Selection in C Generic not Expanded from Macro Parameters Unnecessary override Specifier Unnecessary virtual Specifier Unreachable Call Unreachable Computation Unreachable Conditional Unreachable Control Flow Unreachable Data Flow Unused Value Useless Assignment	Condition Always False (Ada) Condition Always True (Ada) Condition Predetermined by Single Operand (Ada) Dead Code (Ada) Unused Global Value (Ada) Unused Non-Global Value (Ada) Useless Assignment (Ada)
reliability	Arctangent Domain Error Argument Too High Argument Too Low Array Parameter Mismatch Array to Pointer Conversion on Temporary Object Bad Return Type on Virtual Function Override Bit-field in Union Blocking in Critical Section Cast Removes const Qualifier Cast Removes volatile Qualifier Cast: Non-integer Arithmetic Type/Object Pointer Cast: Virtual Base to Derived Comparison of Unrelated Pointers Conflicting Lock Order Conversion to Type bool Copy-Paste Error Dangerous Function Cast Data Race Deadlock Derived Class From Virtual Base Direct Access to Field of C Atomic Object Division By Zero Double Close Double Initialization Double Lock Double Unlock Encapsulation Violation Enumeration Has Implicit Underlying Type File Open for Both Read and Write Float Division By Zero Float Multiplication Overflow Gamma on Zero Global Variable Declared with Different Types GlobalHandle on GMEM_FIXED Memory GlobalLock on GMEM_FIXED Memory GlobalUnlock on GMEM_FIXED Memory Ignored Return Value Inappropriate Argument to <tgmath.h> Macro Inappropriate Argument to Integer Constant Macro Inappropriate C Atomic Initialization Inappropriate Compare Object Inappropriate Comparison of Virtual Member Function Inappropriate Storage Duration Inappropriate throw in noexcept Function Inconsistent Alignment Specifications Inconsistent Function Declarations Inconsistent Object Declarations Inconsistent Types of Arguments to <tgmath.h> Macro Indeterminate Order of Evaluation Initialization Cycle Input After Output Without Positioning Invalid Preprocessor Directive Leak Local Variable Passed to Thread LocalHandle on LMEM_FIXED Memory LocalLock on LMEM_FIXED Memory LocalUnlock on LMEM_FIXED Memory Locked Twice Logarithm on Negative Value Logarithm on Zero Missing Return Statement Missing Return Value Missing noexcept Missing throw in operator new Multiple Accesses of Atomic Negative file descriptor Non-void noreturn Null Pointer Dereference Null Test After Dereference Output After Input Without Positioning Over-initialized Element Override of final Function Pure final virtual Read Past Null Terminator Risky Atomic Memory Order Risky Range-based for-loop Initializer Socket In Wrong State Specialization after Use Static Array Parameter Subtraction of Unrelated Pointers Try-lock that will never succeed Type Qualifier on Function Type Undefined Power of Zero Unknown Lock Unordered Initialization Use of <stdarg.h> Feature Use of <stdint.h> Small Integer Constant Macro Use of Condition Variable Signal Use of Condition Variable Wait Use of fork Use of gamma Use of pthread_kill Use of setlocale Use of std::locale::global Virtual Call in Constructor Virtual Call in Destructor Void C Atomic Write to Read Only File cosh on High Number cosh on Low Number delete with Non-Virtual Destructor enum Value Out of Underlying Range final Modifier Requires Virtual Function override Member Does Not override sizeof Array Parameter sqrt on Negative Value std::move Argument is Not Lvalue std::move Argument is const typeid of Polymorphic Class Type	Assertion Could Fail (Ada) Close Without Open (Ada) Copy-Paste Error Division By Zero (Ada) Double Open (Ada) Float Division By Zero (Ada) Ignored Out Parameter (Ada) Memory Leak (Ada) Null Pointer Dereference (Ada)	== Always Fails Because Types Always Different (Java) Abs on random (Java) Actual Parameter Element may be null (Java) Ambiguous Call from Inner Class (Java) Android Leak (Java) Approximate e Constant (Java) Approximate pi Constant (Java) Array Parameter Empty (Java) Assertion Contains Side Effects (Java) Assignment in Conditional (Java) Asymmetric compareTo (Java) Bitwise AND on Boolean (Java) Bitwise AND on Boolean Constant (Java) Bitwise OR on Boolean (Java) Bitwise OR on Boolean Constant (Java) Blocking in Critical Section (Java) Broad Throws Clause (Java) Call Might Return Null (Java) Cast: Integer to Floating Point (Java) Cast: int Computation to long (Java) Class Enables Debug Features (Java) Clone Call to Super is Missing (Java) Closeable Not Closed (Java) Closeable Not Stored (Java) Comparison to Class Names (Java) Comparison to Empty String (Java) Copy-Paste Error Debug Call (Java) Debug Warning (Java) Defines equals but not hashCode (Java) Defines hashCode but not equals (Java) Double-Checked Locking (Java) Empty Branch Statement (Java) Empty Exception Handler (Java) Empty jar File Archived (Java) Empty zip File Archived (Java) Explicit Finalize (Java) Field Element may be null (deep) (Java) Field Never Read (Java) Field Never Written (Java) Field Too Visible (Java) Field may be null (deep) (Java) Floating Point Equality (Java) Generic Exception Handler (Java) Hardcoded Filename (Java) Ignored Return Value (Java) Ignored Return Value for Pure Function (Java) Impossible Client Side Locking (Java) Impossible reference comparison (Java) Inappropriate Exception Handler (Java) Inappropriate Instanceof (Java) Inefficient Bitwise AND (Java) Inefficient Bitwise OR (Java) Inefficient Box-Unbox (Java) Inefficient Instantiation (Java) Inner Class Should be Static (Java) Insecure Class Loader (Java) Instanceof Always False (Java) Instanceof Always True (Java) Lambda Parameter may be null (Java) Method Enables Debug Features (Java) Method Names Differ Only in Case (Java) Method Should Not Return null (Java) Method Should be final (Java) Method Should be private (Java) Missing Call to super (Java) Missing Equals Override (Java) Missing JavaScript Entry Point (Java) Missing JavaScript Execution (Java) Missing Serial Version Field (Java) Missing isValidFragment Override (Java) Missing synchronized Statement (Java) Mutable Constant Field (Java) Mutable Enumeration (Java) Mutable Public Static Final Array (Java) Non-Object compareTo Parameter (Java) Non-overriding Method Signature (Java) Nonserializable Field (Java) Nonserializable Field Element (Java) Nonserializable Outer Class (Java) Null Parameter Dereference (Java) Null Pointer Dereference (Java) Null Pointer Dereference (deep) (Java) Potential Infinite Recursion (Java) Redundant Call for Integral Argument (Java) Redundant Call for String Argument (Java) Redundant Condition (Java) Redundant Implements Clause (Java) Reflection Bypasses Member Accessibility (Java) Reflection Modifies Member Accessibility (Java) Return Value may Contain null Element (Java) Return Value may be null (Java) Return null Array (Java) Return null Boolean (Java) Return null Optional (Java) Risky Class Cast (Java) Risky array store (Java) Serialization Not Disabled (Java) Shadowed Identifier (Java) Should Use == Instead of equals() (Java) Should Use equals() Instead of == (Java) Single-use Random Number Generator (Java) Static Field Assigned Non-Static (Java) Static Field Too Visible (Java) Synchronization on Interned String (Java) Synchronization on static (Java) Synchronous Call to Thread Body (Java) Unchecked Parameter Dereference (Java) Unchecked Parameter Dereference (deep) (Java) Unchecked Parameter Element Dereference (deep) (Java) Unexpected Serial Version Field (Java) Unguarded Field (Java) Unguarded Method (Java) Unguarded Parameter (Java) Unnecessary Field (Java) Unnecessary Instantiation for GetClass (Java) Unreachable Instruction (Java) Unused Class (Java) Unused Field (Java) Unused Method (Java) Unused Object (Java) Unused Value: Actual Parameter (Java) Unused Value: Variable (Java) Unused Value: Write to Parameter (Java) Useless Assignment (Java) Useless Assignment to Default (Java) Useless Class Cast (Java) Useless Synchronization (Java) Useless null Test (Java) Useless null Test of Field (Java) Useless null Test of Parameter (Java) Useless null Test of Return Value (Java) Useless volatile Modifier (Java) clone Non-cloneable (Java) clone Subclass of Non-clonable (Java) clone not final (Java) compareTo in Non-Comparable Class (Java) compareTo without equals (Java) compareTo/equals mismatch (Java) equals Always Fails (Java) equals Parameter Should Be Object (Java) equals on Array (Java) null Passed to Method (deep) (Java) toString on Array (Java)	'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument (C#) 'ThreadStatic' only affects static fields (C#) == Always Fails Because Types Always Different (C#) A constant is expected for the parameter (C#) Abs on random (C#) Abstract types should not have public constructors (C#) Actual Parameter Element may be null (C#) All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface (C#) Ambiguous Call from Inner Class (C#) Approximate e Constant (C#) Approximate pi Constant (C#) Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum (C#) Assigning symbol and its member in the same statement (C#) Assignment in Conditional (C#) Asymmetric compareTo (C#) Attribute string literals should parse correctly (C#) Avoid 'StringBuilder' parameters for P/Invokes (C#) Avoid constant arrays as arguments (C#) Avoid dead conditional code (C#) Avoid empty interfaces (C#) Avoid excessive class coupling (C#) Avoid excessive complexity (C#) Avoid excessive inheritance (C#) Avoid excessive parameters on generic types (C#) Avoid inexact read with 'Stream.Read' (C#) Avoid infinite recursion (C#) Avoid out parameters (C#) Avoid redundant length argument (C#) Avoid uninstantiated internal classes (C#) Avoid unmaintainable code (C#) Avoid unsealed attributes (C#) Avoid unused private fields (C#) Avoid using 'Enumerable.Any()' extension method (C#) Avoid using cref tags with a prefix (C#) Avoid zero-length array allocations (C#) Bitwise AND on Boolean (C#) Bitwise AND on Boolean Constant (C#) Bitwise OR on Boolean (C#) Bitwise OR on Boolean Constant (C#) Blocking in Critical Section (C#) Cache and reuse 'JsonSerializerOptions' instances (C#) Call Might Return Null (C#) Call async methods when in an async method (C#) CancellationToken parameters must come last (C#) Cast: Integer to Floating Point (C#) Cast: int Computation to long (C#) Class Enables Debug Features (C#) Closeable Not Closed (C#) Closeable Not Stored (C#) Collection properties should be read only (C#) Comparison to Class Names (C#) Comparison to Empty String (C#) Consider calling ConfigureAwait on the awaited task (C#) Consider making public types internal (C#) Consider using 'StringBuilder.Append(char)' when applicable (C#) Consider using 'string.Contains' instead of 'string.IndexOf' (C#) Copy-Paste Error Debug Call (C#) Debug Warning (C#) Declare types in namespaces (C#) Define accessors for attribute arguments (C#) Defines equals but not hashCode (C#) Defines hashCode but not equals (C#) Disposable fields should be disposed (C#) Disposable types should declare finalizer (C#) Dispose methods should call SuppressFinalize (C#) Dispose methods should call base class dispose (C#) Dispose objects before losing scope (C#) Do not assign a property to itself (C#) Do not call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types (C#) Do not call ToImmutableCollection on an ImmutableCollection value (C#) Do not call overridable methods in constructors (C#) Do not catch general exception types (C#) Do not compare Span<T> to 'null' or 'default' (C#) Do not create tasks without passing a TaskScheduler (C#) Do not declare event fields as virtual (C#) Do not declare protected member in sealed type (C#) Do not declare static members on generic types (C#) Do not declare visible instance fields (C#) Do not define finalizers for types derived from MemoryManager<T> (C#) Do not duplicate indexed element initializations (C#) Do not expose generic lists (C#) Do not hide base class methods (C#) Do not ignore method results (C#) Do not initialize unnecessarily (C#) Do not lock on objects with weak identity (C#) Do not mark enums with FlagsAttribute (C#) Do not overload equality operator on reference types (C#) Do not pass a non-nullable value to 'ArgumentNullException.ThrowIfNull' (C#) Do not pass a nullable struct to 'ArgumentNullException.ThrowIfNull' (C#) Do not pass literals as localized parameters (C#) Do not pass types by reference (C#) Do not raise exceptions in finally clauses (C#) Do not raise exceptions in unexpected locations (C#) Do not raise reserved exception types (C#) Do not use 'OutAttribute' on string parameters for P/Invokes (C#) Do not use 'WaitAll' with a single task (C#) Do not use 'WhenAll' with a single task (C#) Do not use ConfigureAwaitOptions.SuppressThrowing with Task<TResult> (C#) Do not use Count() or LongCount() when Any() can be used (C#) Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used (C#) Do not use Enumerable methods on indexable collections (C#) Do not use ReferenceEquals with value types (C#) Do not use stackalloc in loops (C#) Double-Checked Locking (C#) Empty Branch Statement (C#) Empty Exception Handler (C#) Empty zip File Archived (C#) Enum Storage should be Int32 (C#) Enums should have zero value (C#) Enums values should not be duplicated (C#) Exceptions should be public (C#) Field Element may be null (deep) (C#) Field Never Read (C#) Field Never Written (C#) Field Too Visible (C#) Field may be null (deep) (C#) Floating Point Equality (C#) Forward the 'CancellationToken' parameter to methods (C#) Generic Exception Handler (C#) Generic interface should also be implemented (C#) Hardcoded Filename (C#) Ignored Return Value (C#) Ignored Return Value for Pure Function (C#) Implement IDisposable Correctly (C#) Implement IEquatable when overriding Object.Equals (C#) Implement standard exception constructors (C#) Impossible Client Side Locking (C#) Impossible reference comparison (C#) Improper 'ThreadStatic' field initialization (C#) Inappropriate Exception Handler (C#) Inappropriate Instanceof (C#) Incorrect usage of ConstantExpected attribute (C#) Inefficient Bitwise AND (C#) Inefficient Bitwise OR (C#) Initialize reference type static fields inline (C#) Initialize value type static fields inline (C#) Instanceof Always False (C#) Instanceof Always True (C#) Instantiate argument exceptions correctly (C#) Interface methods should be callable by child types (C#) Invalid entry in code metrics rule specification file (C#) Mark ISerializable types with serializable (C#) Mark all non-serializable fields (C#) Mark assemblies with CLSCompliant (C#) Mark assemblies with ComVisible (C#) Mark assemblies with NeutralResourcesLanguageAttribute (C#) Mark assemblies with assembly version (C#) Mark attributes with AttributeUsageAttribute (C#) Mark enums with FlagsAttribute (C#) Mark members as static (C#) Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static' (C#) Method Enables Debug Features (C#) Method Names Differ Only in Case (C#) Method Should Not Return null (C#) Method Should be final (C#) Method Should be private (C#) Missing Call to super (C#) Missing Equals Override (C#) Missing synchronized Statement (C#) Move pinvokes to native methods class (C#) Mutable Constant Field (C#) Mutable Enumeration (C#) Mutable Public Static Final Array (C#) Named placeholders should not be numeric values (C#) Nested types should not be visible (C#) Non-Object compareTo Parameter (C#) Non-constant fields should not be visible (C#) Non-overriding Method Signature (C#) Nonserializable Field (C#) Nonserializable Field Element (C#) Nonserializable Outer Class (C#) Normalize strings to uppercase (C#) Null Parameter Dereference (C#) Null Pointer Dereference (C#) Null Pointer Dereference (deep) (C#) Operator overloads have named alternates (C#) Operators should have symmetrical overloads (C#) Overload operator equals on overriding value type Equals (C#) Override Object.Equals(object) when implementing IEquatable<T> (C#) Override equals and operator equals on value types (C#) Override methods on comparable types (C#) P/Invokes should not be visible (C#) Parameter count mismatch (C#) Pass system uri objects instead of strings (C#) Possible multiple enumerations of 'IEnumerable' collection (C#) Potential Infinite Recursion (C#) Prefer 'AsSpan' over 'Substring' (C#) Prefer 'Clear' over 'Fill' (C#) Prefer 'Convert.ToHexString' and 'Convert.ToHexStringLower' over call chains based on 'BitConverter.ToString' (C#) Prefer Dictionary.Contains methods (C#) Prefer IsEmpty over Count (C#) Prefer generic overload when type is known (C#) Prefer jagged arrays over multidimensional (C#) Prefer static 'HashData' method over 'ComputeHash' (C#) Prefer strongly-typed Append and Insert method overloads on StringBuilder (C#) Prefer the 'IDictionary.TryAdd(TKey, TValue)' method (C#) Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method (C#) Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync' (C#) Prevent behavioral change (C#) Properties should not be write only (C#) Properties should not return arrays (C#) Property, type, or attribute requires runtime marshalling (C#) Provide ObsoleteAttribute message (C#) Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle' (C#) Provide correct 'enum' argument to 'Enum.HasFlag' (C#) Provide correct arguments to formatting methods (C#) Provide memory-based overrides of async methods when subclassing 'Stream' (C#) Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported (C#) Redundant Call for Integral Argument (C#) Redundant Call for String Argument (C#) Redundant Condition (C#) Reflection Bypasses Member Accessibility (C#) Reflection Modifies Member Accessibility (C#) Remove empty Finalizers (C#) Rethrow to preserve stack details (C#) Return Value may Contain null Element (C#) Return Value may be null (C#) Return null Array (C#) Risky Class Cast (C#) Risky array store (C#) Seal internal types (C#) Set 'MaxResponseHeadersLength' properly (C#) Shadowed Identifier (C#) Should Use == Instead of equals() (C#) Should Use equals() Instead of == (C#) Single-use Random Number Generator (C#) Specify CultureInfo (C#) Specify IFormatProvider (C#) Specify StringComparison for clarity (C#) Specify StringComparison for correctness (C#) Specify a culture or use an invariant version (C#) Specify marshaling for P/Invoke string arguments (C#) Static Field Assigned Non-Static (C#) Static Field Too Visible (C#) Static holder types should be Static or NotInheritable (C#) Synchronization on Interned String (C#) Synchronization on static (C#) Synchronous Call to Thread Body (C#) Template should be a static expression (C#) Test for NaN correctly (C#) Test for empty strings using string length (C#) The 'ModuleInitializer' attribute should not be used in libraries (C#) This API requires opting into preview features (C#) This method uses runtime marshalling even when the 'DisableRuntimeMarshallingAttribute' is applied (C#) Types should not extend certain base types (C#) Types that own disposable fields should be disposable (C#) URI-like parameters should not be strings (C#) URI-like properties should not be strings (C#) URI-like return values should not be strings (C#) Unchecked Parameter Dereference (C#) Unchecked Parameter Dereference (deep) (C#) Unchecked Parameter Element Dereference (deep) (C#) Unguarded Field (C#) Unguarded Method (C#) Unguarded Parameter (C#) Unnecessary Field (C#) Unnecessary call to 'Contains(item)' (C#) Unnecessary call to 'Dictionary.ContainsKey(key)' (C#) Unreachable Instruction (C#) Unused Class (C#) Unused Field (C#) Unused Method (C#) Unused Object (C#) Unused Value: Actual Parameter (C#) Unused Value: Variable (C#) Unused Value: Write to Parameter (C#) Use 'CompositeFormat' (C#) Use 'Environment.CurrentManagedThreadId' (C#) Use 'Environment.ProcessId' (C#) Use 'Environment.ProcessPath' (C#) Use 'StartsWith' instead of 'IndexOf' (C#) Use 'ThrowIfCancellationRequested' (C#) Use 'string.Equals' (C#) Use ArgumentException throw helper (C#) Use ArgumentNullException throw helper (C#) Use ArgumentOutOfRangeException throw helper (C#) Use AsSpan or AsMemory instead of Range-based indexers (C#) Use AsSpan or AsMemory instead of Range-based indexers for getting Span of an array (C#) Use AsSpan or AsMemory instead of Range-based indexers when appropriate (C#) Use Integral Or String Argument For Indexers (C#) Use Length/Count property instead of Count() when available (C#) Use ObjectDisposedException throw helper (C#) Use ValueTasks correctly (C#) Use a cached 'SearchValues' instance (C#) Use char literal for a single character lookup (C#) Use char overload, CA1865 (C#) Use char overload, CA1866 (C#) Use char overload, CA1867 (C#) Use concrete types when possible for improved performance (C#) Use correct type parameter (C#) Use events where appropriate (C#) Use generic event handler instances (C#) Use literals where appropriate (C#) Use nameof to express symbol names (C#) Use ordinal string comparison (C#) Use properties where appropriate (C#) Use span-based 'string.Concat' (C#) Use the 'StringComparison' method overloads to perform case-insensitive string comparisons (C#) Use the LoggerMessage delegates (C#) Use valid platform string (C#) Useless Assignment (C#) Useless Assignment to Default (C#) Useless Class Cast (C#) Useless Synchronization (C#) Useless null Test (C#) Useless null Test of Field (C#) Useless null Test of Parameter (C#) Useless null Test of Return Value (C#) Useless volatile Modifier (C#) Validate arguments of public methods (C#) Validate platform compatibility (C#) Validate platform compatibility - obsoleted APIs (C#) clone Non-cloneable (C#) clone Subclass of Non-clonable (C#) clone not final (C#) compareTo in Non-Comparable Class (C#) compareTo without equals (C#) compareTo/equals mismatch (C#) equals Always Fails (C#) equals Parameter Should Be Object (C#) equals on Array (C#) null Passed to Method (deep) (C#) toString on Array (C#)
security	Addition Overflow of Allocation Size Addition Overflow of Size Buffer Overrun Buffer Underrun Cast Alters Value Coercion Alters Value Command Injection Conversion from Function Pointer Conversion to Function Pointer Default Initialization of Random Number Generator Default Seed in PRNG Double Free Encryption without Padding File System Race Condition Format String Format String Injection Format String Type Error Function Call Has No Effect Hardcoded Authentication Hardcoded Crypto Key Hardcoded Crypto Salt Hardcoded DNS Name Hardcoded Seed in PRNG Inappropriate Call Outside Loop Incorrect Privilege Assignment Inline Assembly Code Integer Overflow of Allocation Size LDAP Injection Library Function Override Library Injection MAX_PATH Exceeded Memory Protection Removal Misaligned Object Multiplication Overflow of Allocation Size Multiplication Overflow of Size Negative Character Value Negative Shift Amount No Space For Null Terminator Null Security Descriptor Overlapping Memory Regions Padding Passed Across a Trust Boundary Plaintext Storage of Password Plaintext Transmission of Password Pool Mismatch Possible Anti-Debugging Predictable Seed in PRNG Return Pointer to Freed Return Pointer to Local Return from Computational Exception Signal Handler Return from noreturn Returned Pointer Not Treated as const SQL Injection Shift Amount Exceeds Bit Width Subtraction Underflow of Allocation Size Subtraction Underflow of Size Tainted Allocation Size Tainted Buffer Access Tainted Configuration Setting Tainted Environment Variable Tainted Filename Tainted Network Address Tainted Write Thread is not Joinable Truncation of Allocation Size Truncation of Size Type Mismatch Type Overrun Type Underrun Uninitialized Variable Unreasonable Size Argument Unterminated C String Untrusted Library Load Untrusted Network Host Untrusted Network Port Untrusted Process Creation Use After Close Use After Free Use of CreateFile Use of CreateProcess Use of CreateThread Use of FormatMessage Use of GetTempFileName Use of LoadLibrary Use of LoadModule Use of MoveFile Use of OemToAnsi Use of OemToChar Use of SHCreateProcessAsUserW Use of SO_REUSEADDR Use of ShellExecute Use of StrCatChainW Use of Weak Cryptographic Algorithm Use of WinExec Use of XML_ExternalEntityParserCreate Use of _exec Use of _spawn Use of catopen Use of chroot Use of crypt Use of cuserid Use of execlp Use of execvp Use of getlogin Use of getopt Use of getpass Use of getwd Use of memcmp Use of memset Use of mkstemp Use of mktemp Use of popen Use of rand Use of rand48 Function Use of random Use of realloc Use of realpath Use of recvmsg Use of setuid Use of signal Use of strcat Use of strchr Use of strcmp Use of strcoll Use of strcpy Use of strcspn Use of strlen Use of strpbrk Use of strrchr Use of strspn Use of strstr Use of strtok Use of strtrns Use of syslog Use of t_open Use of tmpfile Use of tmpnam Use of ttyname Use of vfork Varargs Function Cast Weak Cryptography chroot without chdir	Array Length Mismatch (Ada) Base Type Overflow/Underflow (Ada) Code Injection (Ada) Command Injection (Ada) Cross Site Scripting (Ada) Double Free (Ada) Inappropriate Array Index (Ada) OS Command Injection (Ada) Return Pointer to Local (Ada) SQL Injection (Ada) Tainted Filename (Ada) Type Range Overflow/Underflow (Ada) Use After Free (Ada)	Accessing File in Permissive Mode (Java) Android Message Injection (Java) Android URL Injection (Java) Anonymous LDAP Authentication (Java) Certificate Added to Root Store (Java) Code Injection (Java) Command Injection (Java) Cross Site Scripting (Java) Cross Site Scripting In Error Message Web Page (Java) Cryptographic Algorithm with Risky Default Cipher (Java) Cryptographic Algorithm with Weak Cipher (Java) Cryptographic Algorithm with Weak Hash (Java) DLL Injection (Java) DOS Injection (Java) Deprecated Cryptography Provider (Java) Deprecated Transfer Protocol (Java) Deserializable Class (Java) Deserializing Non-Serializable Class (Java) Direct Thread Usage in Http Servlet (Java) Exception Information Disclosure (Java) Execution After Redirect (Java) Format String Injection (Java) Fragment Injection (Java) Hardcoded Cryptographic Key (Java) Hardcoded IP Address (Java) Hardcoded Password (Java) Hardcoded Random Seed (Java) Hostname in Condition (Java) Inadequate Salt (Java) Ineffective Cleansing of Fragment Taint (Java) Insecure Cookie (Java) Insecure Key Derivation (Java) Insecure Random Number Generator (Java) Insecure Socket Factory (Java) Insecure XSLT Execution (Java) Insecure verifier Override for Hostname (Java) Insecure verify Override for Certificate (Java) JavaScript Enabled (Java) JavaScript File Access from File URLs (Java) LDAP Authentication Disabled (Java) Legacy Random Generator (Java) Method Disables Security Setting (Java) Missing Authentication Annotation (Java) Missing Required Cryptographic Step (Java) Open Redirect (Java) Password in Property File (Java) Permissive File Mode (Java) Possible XML External Entity Reference (Java) Potential LDAP Poisoning (Java) Reflection Injection (Java) Risky Cipher Algorithm (Java) Risky Cipher Field (Java) Risky Cryptographic Algorithm (Java) Risky Cryptographic Field (Java) Risky JavaScript Interface (Java) SQL Injection (Java) Security Annotation Conflict (Java) Sensitive Data Cached (Java) Sensitive Data Written to External Storage (Java) Sensitive Data Written to Local File (Java) Tainted @Trusted Value (Java) Tainted Allocation Size (Java) Tainted Bundle (Java) Tainted Control (Java) Tainted Data in Vulnerable Method (Java) Tainted Expression Evaluation (Java) Tainted HTTP Response (Java) Tainted Hardware Device Property (Java) Tainted LDAP Attribute (Java) Tainted LDAP Filter (Java) Tainted Log (Java) Tainted Message (Java) Tainted Network Address (Java) Tainted Path (Java) Tainted Regular Expression (Java) Tainted Resource (Java) Tainted Session (Java) Tainted URL (Java) Tainted XAML (Java) Tainted XML (Java) Tainted Xpath (Java) Universal JavaScript Access to File URLs (Java) Unsafe Base64 Encoding (Java) Unsafe Session Expiration Time (Java) Unsafe hash comparison (Java) Untrusted Network Host (Java) Use of Hardware ID (Java) Use of Hash without a Salt (Java) Use of Insecure verify for Certificate (Java) Use of Insecure verify for Hostname (Java) Use of Same Seed (Java) Weak Cryptographic Value (Java) Weak Hash Algorithm (Java) Weak Hash Algorithm Field (Java) Weak Initialization Vector Field (Java) Weak Initialization Vector Value (Java)	Anonymous LDAP Authentication (C#) Avoid hardcoded SslProtocols values (C#) Avoid hardcoding SecurityProtocolType value (C#) Certificate Added to Root Store (C#) Code Injection (C#) Command Injection (C#) Cross Site Scripting (C#) Cross Site Scripting In Error Message Web Page (C#) Cryptographic Algorithm with Risky Default Cipher (C#) Cryptographic Algorithm with Weak Cipher (C#) Cryptographic Algorithm with Weak Hash (C#) DLL Injection (C#) DOS Injection (C#) Deprecated Cryptography Provider (C#) Deprecated Transfer Protocol (C#) Deserializable Class (C#) Disabled Input Validation (C#) Do Not Add Archive Item's Path To The Target File System Path (C#) Do Not Add Certificates To Root Store (C#) Do Not Add Schema By URL (C#) Do Not Call Dangerous Methods In Deserialization (C#) Do Not Catch Corrupted State Exceptions (C#) Do Not Disable Certificate Validation (C#) Do Not Disable HTTP Header Checking (C#) Do Not Disable Request Validation (C#) Do Not Disable SChannel Use of Strong Crypto (C#) Do Not Serialize Types With Pointer Fields (C#) Do Not Use Account Shared Access Signature (C#) Do Not Use Broken Cryptographic Algorithms (C#) Do Not Use Deprecated Security Protocols (C#) Do Not Use Digital Signature Algorithm (DSA) (C#) Do Not Use Weak Cryptographic Algorithms (C#) Do Not Use Weak Key Derivation Function With Insufficient Iteration Count (C#) Do Not Use XslTransform (C#) Do not always skip token validation in delegates (C#) Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder (C#) Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver (C#) Do not deserialize with JsonSerializer using an insecure configuration (C#) Do not deserialize without first setting NetDataContractSerializer.Binder (C#) Do not disable ServicePointManagerSecurityProtocols (C#) Do not disable token validation checks (C#) Do not hard-code certificate (C#) Do not hard-code encryption key (C#) Do not use CreateEncryptor with non-default IV (C#) Do not use DataSet.ReadXml() with untrusted data (C#) Do not use DataTable.ReadXml() with untrusted data (C#) Do not use TypeNameHandling values other than None (C#) Do not use deprecated SslProtocols values (C#) Do not use insecure JsonSerializerSettings (C#) Do not use insecure deserializer BinaryFormatter (C#) Do not use insecure deserializer LosFormatter (C#) Do not use insecure deserializer NetDataContractSerializer (C#) Do not use insecure deserializer ObjectStateFormatter (C#) Do not use insecure randomness (C#) Do not use obsolete key derivation function (C#) Do not use unsafe DllImportSearchPath value (C#) Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize (C#) Ensure Certificates Are Not Added To Root Store (C#) Ensure HttpClient certificate revocation list check is not disabled (C#) Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing (C#) Ensure Key Derivation Function algorithm is sufficiently strong (C#) Ensure NetDataContractSerializer.Binder is set before deserializing (C#) Ensure Sufficient Iteration Count When Using Weak Key Derivation Function (C#) Ensure Use Secure Cookies In ASP.NET Core (C#) Ensure auto-generated class containing DataSet.ReadXml() is not used with untrusted data (C#) Ensure that JsonSerializer has a secure configuration when deserializing (C#) Ensure that JsonSerializerSettings are secure (C#) Exception Information Disclosure (C#) Execution After Redirect (C#) Format String Injection (C#) Hardcoded Cryptographic Key (C#) Hardcoded IP Address (C#) Hardcoded Password (C#) Hardcoded Random Seed (C#) Hostname in Condition (C#) HttpClients should enable certificate revocation list checks (C#) Inadequate Salt (C#) Insecure Cookie (C#) Insecure DTD processing in XML (C#) Insecure Key Derivation (C#) Insecure Processing in API Design, XmlDocument and XmlTextReader (C#) Insecure Random Number Generator (C#) Insecure XSLT Execution (C#) Insecure XSLT script processing (C#) Legacy Random Generator (C#) Mark Verb Handlers With Validate Antiforgery Token (C#) Method Disables Security Setting (C#) Miss HttpVerb attribute for action methods (C#) Missing Authentication Annotation (C#) Missing Required Cryptographic Step (C#) Open Redirect (C#) Password in Property File (C#) Possible XML External Entity Reference (C#) Potential reference cycle in deserialized object graph (C#) Reflection Injection (C#) Review SQL queries for security vulnerabilities (C#) Review cipher mode usage with cryptography experts (C#) Review code for DLL injection vulnerabilities (C#) Review code for LDAP injection vulnerabilities (C#) Review code for SQL injection vulnerabilities (C#) Review code for XAML injection vulnerabilities (C#) Review code for XML injection vulnerabilities (C#) Review code for XPath injection vulnerabilities (C#) Review code for XSS vulnerabilities (C#) Review code for file path injection vulnerabilities (C#) Review code for information disclosure vulnerabilities (C#) Review code for open redirect vulnerabilities (C#) Review code for process command injection vulnerabilities (C#) Review code for regex injection vulnerabilities (C#) Risky Cipher Algorithm (C#) Risky Cipher Field (C#) Risky Cryptographic Algorithm (C#) Risky Cryptographic Field (C#) SQL Injection (C#) Seal methods that satisfy private interfaces (C#) Security Annotation Conflict (C#) Set HttpOnly to true for HttpCookie (C#) Set ViewStateUserKey For Classes Derived From Page (C#) Tainted @Trusted Value (C#) Tainted Allocation Size (C#) Tainted Bundle (C#) Tainted Control (C#) Tainted Expression Evaluation (C#) Tainted HTTP Response (C#) Tainted Hardware Device Property (C#) Tainted LDAP Attribute (C#) Tainted LDAP Filter (C#) Tainted Log (C#) Tainted Message (C#) Tainted Network Address (C#) Tainted Path (C#) Tainted Regular Expression (C#) Tainted Resource (C#) Tainted Session (C#) Tainted URL (C#) Tainted XAML (C#) Tainted XML (C#) Tainted Xpath (C#) Unsafe Base64 Encoding (C#) Unsafe DataSet or DataTable in auto-generated serializable type can be vulnerable to remote code execution attacks (C#) Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attacks (C#) Unsafe DataSet or DataTable in serializable type (C#) Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks (C#) Unsafe DataSet or DataTable type found in deserializable object graph (C#) Unsafe DataSet or DataTable type in web deserializable object graph (C#) Unsafe Session Expiration Time (C#) Unsafe hash comparison (C#) Use Container Level Access Policy (C#) Use CreateEncryptor with the default IV (C#) Use DefaultDllImportSearchPaths attribute for P/Invokes (C#) Use Rivest-Shamir-Adleman (RSA) Algorithm With Sufficient Key Size (C#) Use Secure Cookies In ASP.NET Core (C#) Use SharedAccessProtocol HttpsOnly (C#) Use XmlReader for 'DataSet.ReadXml()' (C#) Use XmlReader for 'XmlSchema.Read()' (C#) Use XmlReader for 'XmlSerializer.Deserialize()' (C#) Use XmlReader for XPathDocument constructor (C#) Use XmlReader for XmlValidatingReader constructor (C#) Use antiforgery tokens in ASP.NET Core MVC controllers (C#) Use of Hash without a Salt (C#) Use of Same Seed (C#) Weak Cryptographic Value (C#) Weak Hash Algorithm (C#) Weak Hash Algorithm Field (C#) Weak Initialization Vector Field (C#) Weak Initialization Vector Value (C#)
style	"(" After Function ## Follows # Operator #assert Directive #else Already Appeared #error Directive #include Recursion #include_next in Primary Source File #info Directive #pragma GCC system_header in Primary File #pragma Inside Function #pragma May Not Be Used Here #pragma Must Precede Declaration #pragma Must Precede Declaration or Statement #pragma Must Precede Statement #pragma pack(show) Arguments Ignored --anachronisms Requires C++ --arg_dep_lookup Requires C++ --array_new_and_delete Requires C++ --auto_instantiation Requires C++ --auto_storage Requires C++ --auto_type Requires C++ --bool Requires C++ --c23_typeof Requires C --class_name_injection Requires C++ --compound_literals Requires C --cs_iar Deprecated --cs_iar Unrecognized --dep_name Requires C++ --embedded_c Incompatible With Individual Feature Options --embedded_c Requires C --embedded_c++ Requires C++ --enum_overloading Requires C++ --exceptions Requires C++ --explicit Requires C++ --export Incompatible With --no_dep_name --export Incompatible With Modules --export Requires C++ --extended_designators Requires C --extern_inline Requires C++ --fixed_point Requires C --for_init_diff_warning Requires C++ --friend_injection Requires C++ --func_prototype_tags Requires C --gen_move_operations Incompatible With --rvalue_ctor_is_copy_ctor --gen_move_operations Requires C++ --guiding_decls Requires C++ --ignore_std Requires C++ --implicit_include Requires C++ --implicit_typename Requires C++ --lambdas Requires C++ --late_tiebreaker Requires C++ --named_address_spaces Requires C --named_registers Requires C --namespaces Requires C++ --nonstd_qualifier_deduction Requires C++ --nonstd_using_decl Requires C++ --old_for_init Requires C++ --old_specializations Requires C++ --one_instantiation_per_object Requires C++ --parse_templates Requires C++ --pending_instantiations Requires C++ --rtti Requires C++ --rvalue_ctor_is_copy_ctor Requires C++ --special_subscript_cost Requires C++ --svr4 Requires ANSI C --type_traits_helpers Requires C++ --typename Requires C++ --unrestricted_unions Requires C++ --vla Requires C .ii File Name Incompatible With Multiple Inputs /* in // Comment // in Comment 3rd Argument of __builtin_assumed_aligned Must Be Integral Absolute File Name in __has_include_next Abstract Class Object Not Allowed Abstract Class Parameter Type Abstract Class catch Type Abstract Declarator Pack Is Nested Access Already Specified Access Prevents Destructor Generation Access Suppresses Copy Assignment Declaration Access Suppresses Copy Constructor Declaration Address of Array Address of Bit Field Address of Constructor or Destructor Address of Function With pass_object_size Attribute Address of Managed Member Function Address of Nontrue enable_if Function Address of Reference Class Address of Unqualified Explicit this Function Address of consteval Function Address of consteval Function Leaked Address of initonly Field Address of register Variable Alias Cannot Have Definition Alias Declaration Requires C++11 Alias Loop Alias Template Deduction Guide Alias Template Requires C++11 Alias Used in Type Aliased Name Bad Kind Aliased Name Undeclared Aliased Variable Cannot Have register Storage Class Align Not Equivalent Alignment Reduction Ignored Alignment Reduction Unconditionally Ignored All Arguments Must Have Same Type All Prototyped Parameters Must Be Named Allocation Operator in namespace Already Defined Already Initialized Already in consteval Context Ambiguous Assignment Operator Ambiguous Base Class Ambiguous Block Size Specification Ambiguous C11 Generic Ambiguous C11 Generic Previous Match Ambiguous Cast Selects Direct Base Ambiguous Class Call Ambiguous Constructor Ambiguous Constructor for Conversion Ambiguous Conversion Function Ambiguous Conversion to Builtin Ambiguous Copy Constructor Ambiguous Default Constructor Ambiguous Derived Class Ambiguous Destructor Ambiguous Destructor Constraints Ambiguous Finalizer Ambiguous Function for Delegate Ambiguous Guiding Declaration Ambiguous Injected Template Name Ambiguous Literal Operator Ambiguous Microsoft Attribute Ambiguous Name Ambiguous Operator Function Ambiguous Option Ambiguous Overloaded Function Ambiguous Partial Specialization Ambiguous Pointer to Overloaded Function Ambiguous Question Operator Ambiguous Suppresses Copy Assignment Declaration Ambiguous Suppresses Copy Constructor Declaration Ambiguous User Defined Conversion Ambiguous Virtual Function Override Annotation After using Annotation Must Have Literal Type Anonymous Namespace in Header File Anonymous union Alias Member Template Anonymous union Class Member Template Anonymous union Member Access Anonymous union Member Function Anonymous union Qualifier Ignored Anonymous union Reference in Lambda Anonymous union Storage Class Anonymous union at Declaration Position Anonymous union using Declaration Apparent Module Preprocessor Directive Argument for Empty Parameter Pack Arguments Provided for Attribute Array Condition Always True Array Member Initialization Array Parameter Array Size Must Be Positive Array Size One Assumed Array Size Too Large Array Subobject Not Initialized Array Type Not Allowed Array of Abstract Class Array of Function Array of Generic Parameter Array of Handle Array of Incomplete Type Array of Managed Class Array of Reference Array of void Array to Pointer Decay Assembly Pragma Assign Where Compare Meant Assigned goto Requires void Pointer Assignment Result in Expression Assignment in Conditional Assignment in Value Class Type Assignment to this Assumption Failed Atomic Constraint Evaluation Failed Atomic Constraint False Atomic Constraint Substitution Failed Attempt to Read Past End of Object Attribute After Parenthesized Initializer Attribute Argument Out of Small Integer Range Attribute Conflict Attribute Declared Here Attribute Disallows Automatic Storage Attribute Disallows Bit Field Attribute Disallows Definition Attribute Disallows External Linkage Attribute Disallows Function Type Attribute Disallows Handler Parameter Attribute Disallows Member Function Attribute Disallows Pure Virtual Function Attribute Disallows Virtual Function Attribute Disallows inline Attribute Disallows register Storage Attribute Does Not Apply to Local Variable Attribute Does Not Apply to Type Attribute Ignored for Thread-local Attribute Ignored on Incomplete Class Declaration Attribute Ignored on Non-static Member Function Attribute Ignored on Nondefinition Attribute Ignored on Unnamed Type Attribute Is GNU Extension Attribute Is Nonstandard Attribute Must Also Appear in First Declaration Attribute Must Appear in Class Definition Attribute Not Allowed Attribute Not Applied to Function Type Attribute Not Supported in x86_64 Attribute Requires Automatic Storage Attribute Requires Bit Field Attribute Requires Definition Attribute Requires External Linkage Attribute Requires Function Type Attribute Requires Handler Parameter Attribute Requires Local Variable Attribute Requires Member Function Attribute Requires Pure Virtual Function Attribute Requires Virtual Function Attribute Requires inline Attribute Requires register Storage Attribute Twice in Group Attribute cleanup Requires Automatic Storage Attribute cleanup for Parameter Attribute namespace Unrecognized Attribute on Explicit Instantiation Attributes Ignored Attributes With No Declaration Attributes in Routine Definition Back End Requires IL File Backwards goto Bad #pragma Comment String Bad Address of Ellipsis Bad Affinity Bad Alias Template Redeclaration Bad Argument Type for operator new Bad Argument for __bases Bad Argument for __underlying_type Bad Argument to __make_signed Bad Argument to __make_unsigned Bad Array Element Type Bad Array Member Initialization Bad Assembly Index Bad Attribute Alignment Bad Attribute Template Substitution Bad Base Class Bad Binary Digit Bad Bit Field Size Bad Bit Field Type Bad C++/CX Event add Return Bad C++/CX Event remove Parameter Bad C++/CX Event remove Return Bad C++/CX dynamic_cast Type Bad C++11 Constant Function Call Bad CLI dynamic_cast Type Bad Call of Class Object Bad Call of Handle Bad Cast Bad Character Value Bad Class Template Declaration Bad Combination of DLL Attributes Bad Combination of Type Specifiers Bad Command Line Bad Command Line Macro Bad Complex Operation Result Bad Compound Literal Type Bad Constant Function Call Bad Constant Lambda Bad Constant Operator Bad Constructor Declaration Bad Constructor Parameter Bad Constructor Type Bad Conversion Constant Expression Type Bad Conversion Function Declaration Bad Data Member Initialization Bad Declaration for export Bad Deduction Guide Access Bad Deduction Guide Return Type Bad Deduction Guide Scope Bad Default Argument Type Bad Default Assignment Bad Delegate Initialization Priority List Bad Destructor Declaration Bad Digit Separator Position Bad Event Compound Assignment Bad Event add or remove Return Bad Exception Specification for Specialization Bad Export Information File Bad Extra Argument for Postfix Operator Bad File Scope Storage Class Bad Final __builtin_fpclassify Argument Bad Finalizer Declaration Bad First Argument Type for operator delete Bad Fixed Operation Result Bad Fixed Point Value Bad Float Constant Bad Float Operation Result Bad Float Value Bad Float or Fixed Suffix Bad Function Return Type Bad Function Storage Class Bad Function for Delegate Bad Function for GNU va_arg Pack Bad GNU Statement Return Bad GRO on Allocation Fail Bad Generic Declaration Scope Bad Handle dynamic_cast Operand Bad Hex Digit Bad Identifier String Bad Initialization Priority Capture Capture Bad Initialization Priority for Thread-local Bad Initializer Type Bad Initializer for Array With Unspecified Bound Bad Injection Scope Bad Integral Compound Literal Bad Integral Operator Bad Line Number Bad Linkage Specifier Bad Linkage for Declaration Bad Linkage for Redefine External Name Bad Linkage of Reference Within inline Function Bad Local Variable in Lambda Bad Macro Mode Name Bad Macro Redefine Bad Member Storage Class Bad Member Template Declaration Bad Member Template Symbol Bad Member Type in Pointer to Member Bad Multibyte Character Bad Multibyte Character Locale Bad Non-const Reference Initializer Bad Nonstandard Anonymous union Field Bad Nontype Template Argument Bad Octal Digit Bad Ordering Type Bad PCH File Bad Pack Alignment Bad Parameter Kind for Generic Bad Parameter Specifier Bad Parameter Storage Class Bad Parameter Type for Defaulted Comparison Bad Parameter Type for static Member Operator Bad Partial Specialization Bad Pointer dynamic_cast Operand Bad Predefined Macro Line Bad Predefined Macro Redefine Bad Preprocessor Directive Keyword Bad Preprocessor Operator Bad Property get Return Bad Property set Return Bad Prototype Argument for __bases Bad Pure Specifier Bad Qualified Function Type Bad Qualified Function Type Parameter Bad Qualifier for Delayed Class Definition Bad Qualifier for Member enum Declaration Bad Qualifier for Nested Class Declaration Bad Raw String Delimiter Character Bad Reference dynamic_cast Operand Bad Reflection Kind for Expression Splice Bad Register Name Bad Return Type for operator delete Bad Return Type for operator new Bad Return Type on main Bad Return Value Type Bad Rvalue Array Bad Rvalue Reference const_cast Operand Bad Rvalue Reference dynamic_cast Operand Bad STDC #pragma Argument Bad STDC #pragma Argument for Mode Bad STDC Fixed-point Overflow #pragma Argument Bad Scope for Defaulted Comparison Bad Scope for Definition Bad Scope for Explicit Instantiation Bad Scope for Partial Specialization Bad Scope for Redeclaration Bad Scope for Specialization Bad Scope for concept Bad Shared Storage Class Bad Size for Static Address Initialization Bad Specifier Outside Class Declaration Bad Splicer Operand Bad Statement in Statement Expression Bad Storage Class With inline Bad Storage Class for Named Address Space Variable Bad Storage Class on Template Declaration Bad Strong using Scope Bad Suffix Bad Template Argument Expression Operator Bad Template Declaration Bad Template Declaration Scope Bad Template Member Definition Bad Template Name Bad Token Bad Tracking Reference Initializer Bad Tracking Reference dynamic_cast Operand Bad Type From Instantiation Bad Type Name Redeclaration Bad Type Qualifier Bad Type for Atomic Fetch Bad Type for Cleanup Routine Bad Type for GNU __sync Function Bad UPC Shared Array Layout Qualifier Bad UPC Shared Pointer Layout Qualifier Bad UPC Shared void Pointer Layout Qualifier Bad Unary * Operand Bad Unevaluated Lambda Bad Unicode Character in Preprocessor Output Bad Unicode Character in String Bad Use of "#" Bad Use of CLI Array Type Bad Use of Delegate Type Bad Use of Function Modifier Bad Use of Member Function typedef Bad Use of main Bad User Defined Suffix Bad Variable for-init Priority Bad Vector Conditional Size Bad Vector Float Operand Size Bad _Noreturn Bad __auto_type Bad __declspec restrict Return Bad __declspec(property) Bad asm Constraint Letter Bad asm Constraint Modifier Bad asm Function Definition Bad asm Function Ellipsis Bad assembly_info Attribute Bad const volatile Reference Initializer Bad const_cast Bad const_cast Type Bad csonar_ignore String Bad decltype Qualifier Bad dynamic_cast Type Bad enum Template Declaration Bad friend Declaration Bad malloc Attribute Bad printf Format String Bad return Bad std::string_view Bad this Bad tls_model Attribute Argument Bad union Field Bad uuid String Bad va_arg Bad va_copy Bad va_end Bad va_start Base Class Already Initialized Base Class Has Different DLL Interface Base Class Initializer Anachronism Base Class Not Allowed for union Base Class Offset Too Large Base Class With Nonvirtual Destructor Base Subobject Not Initialized Base Uses Tail Padding Base With Flexible Array Based Requires Variable Name Bases Not in Template Basic Numerical Type Used Bit-field Signedness Not Explicit Bitfields Not Allowed Block Scope Function Must Be extern Block extern Initializer Not Allowed Body Is Not Compound Statement Boolean Controlling Expression Is Constant Boolean switch Expression Both Arguments Must Have Same Type Both Reference and Value Constraints Bound Function Cast Anachronism Bound Function Must Be Called Brace Initialization Not Allowed Braced Initialization Priority List Not Allowed Braced Initialization Priority in Parentheses Braced Initialization Priority in Parenthesized Initializer Braced Initializer with auto Braced List Passed to Ellipsis Braced List for Implicit Lambda Type Braced List for Implicit Return Type Braced List for Microsoft Parameter Array Branch Into Handler Branch Into Statement Expression Branch Into constexpr if Branch Into finally Branch Into if consteval Branch Into try Block Branch Out of Constant Branch Past Initialization Builtin Function Hidden Builtin Function Overloaded Builtin Needs 128 Bit Floats Builtin Needs 128 Bit Integers Builtin Needs Vector Types Builtin Needs char8_t Builtin Operator Nonviable Because Argument Mismatch C String C++ Comment in C C++/CLI Attribute Only C++/CLI Enumerator Requires Explicit Value C++/CLI Explicit Conversion Is Virtual C++/CLI Explicit Conversion Requires Reference and Value Classes C++/CLI Not Enabled C++/CLI Requires Microsoft C++ C++/CLI Requires Newer ABI Version C++/CX Array Only One Dimension Allowed C++/CX Bad Delegate Initialization Priority List C++/CX Box Invalid Type C++/CX Generic Constraints Not Allowed C++/CX Generic Method Not Allowed C++/CX Generic Type Not Allowed C++/CX Handle or Reference to Generic Parameter C++/CX Invalid Array Property set Value Parameter C++/CX Invalid Delegate Object C++/CX Non-const Array Parameter C++/CX Not Enabled C++/CX Public Global Type C++/CX Public Indexed Property C++/CX Public Native Type C++/CX Public Nested Delegate C++/CX Public Value Class Constructor C++/CX Requires Microsoft C++ C++/CX Tracking Reference on Standard Class Type C++/CX Value Type Contains Virtual Function C++/CX Value Type Deriving From Interface C++/CX and C++/CLI C++/CX enum Base Has No Platform Counterpart C++20 Reversed Comparison Ambiguity C-style Cast C99 Constant in Unsigned Long Long Range CLI Abstract Member Function Definition CLI Array Invalid Element Type CLI Array Invalid Number of Dimensions CLI Array Invalid Number of Subscripts CLI Array Must Have new or Array Initialization Priority CLI Attribute Inaccessible Field CLI Attribute Invalid Argument CLI Attribute Invalid Field CLI Entity Not Loaded CLI Interface Cannot Have Assignment CLI Interface Member Function Definition CLI Parameter Array Attribute Deprecated CLI Parameter Array Must Be Last Parameter CLI enum Base Has No System Counterpart CLI get Accessor Missing CLI set Accessor Missing CLI typeid of Generic Parameter in Attribute CLI typeid of Managed Pointer Call Requires Floating Point Argument Call Requires One Argument Call Requires String Literal Call Result Should Be Used Call With Unusable Argument Conversion Call of Pure Virtual Call of Zero Called Function Redeclared inline Calling Convention Ignored Calling Convention Ignored for Type Calling Convention May Not Precede Nested Declarator Calling Convention Not Allowed Candidate Explicit Template Argument Substitution Failed Candidate Failed Constraint Candidate Wrong Parameter Count Cannot #undef Predefined Macro Cannot Assign to Microsoft Attribute Cannot Be Declared in Scope Cannot Be common internal_linkage Cannot Be const-qualified Cannot Build Temporary File Name Cannot Call Member on Lvalue Cannot Call Member on Rvalue Cannot Call Named Member on Lvalue Cannot Call Named Member on Rvalue Cannot Capture Variable Cannot Capture this Cannot Capture this by Reference Cannot Cast Away const Cannot Change Access Cannot Create Instantiation Request File Cannot Deduce Class Template Arguments Cannot Deduce Type in Range-based for Cannot Deduce auto Template Parameter Cannot Deduce auto Type Cannot Deduce decltype(auto) Type Cannot Define dllimport Function Cannot Elide Braces Cannot Evaluate __builtin_offsetof Cannot Export Fragment Cannot Find Header for Import Cannot Import Metadata Cannot Import Module Cannot Import Module Bad Checksum Cannot Import Module With No Name Cannot Initialization Priority auto Flexible Array Member Cannot Initialize Cannot Initialize Destructible Flexible Array Cannot Initialize Fields Cannot Initialize Flexible Array Member Cannot Initialize Indirect Flexible Array Cannot Interpret Target Bits Cannot Open File Cannot Open PCH Input File Cannot Redefine Predefined Macro Cannot Splice General Expression Cannot Splice Member Access Cannot Use Thread-local Storage Cannot chdir Cannot inline Cannot inline Call Capture Mode Matches Default Capture of static Duration Variable Captured Local Variable Not in Innermost Function Captured Variable Type Not Copyable Capturing Structured Bindings Requires C++20 Cast Interior Pointer to Pointer Cast Not Arithmetic or enum or Pointer Cast Not Integral Cast Not Integral or enum Cast Not Scalar Cast in Requires Clause Cast to Abstract Class Cast to Bad Type Cast to CLI Interface Class Cast to Incomplete Array Type Cast to Qualified Type Cast: Arithmetic Type/Void Pointer Cast: Object Pointers Cast: reinterpret_cast Cfront Incompatible With Microsoft Character Not Latin 1 Character Too Wide for Rep Circular Constraint Circular Constraints Class Definition in Statement Expression Class Metadata Not Representable Class Qualified Name Not Allowed Class Qualified Name Required Class Template Same Name as Template Parameter Class Too Large Class Type Required Class With operator delete but No operator new Class With operator new but No operator delete Class and Inherited Member Instance Have DLL Interface Class and Member Function Name Conflict Class and Member Have DLL Interface Class and Member Name Conflict Code Before #include Code Is Unreachable Coercion: Integer Constant to Pointer Comma Operator in Array Subscript Deprecated Comma Operator in CLI Subscript Comment Suggests Code Unfinished Comment Unclosed at EOF Commented-out Code Comparison Defaulted in Class Must Be First Declaration Comparison Operator Does Not Return bool Comparison of Pointers to void and Function Compilation Error in File Compiler Generated Function Cannot Be Instantiated Complex Integral Type Complex Template Parameter Complex Type Not Allowed Compound Literal Is Nonstandard Compound Lvalue as asm Operand Concatenation Yields Invalid Token Condition Contains Side Effects Condition Declaration Must Have Initializer Condition Does Not Declare a Variable Condition Is Not Boolean Condition With Multiple Declarators Conditional Compilation Conflicting Attribute in Other Translation Unit Conflicting CLI Class Template Kinds Conflicting CLI Class Type Kinds Conflicting Calling Conventions Conflicting Nullability Conflicting Properties Conflicts With Predeclared Type Conflicts With using Declaration Confusable Identifier Confusing Initializer-list Constructor Confusing Literal Suffix Confusing Operator Overload Constant Addresses Local Variable Constant Must Be Positive Constant Narrowing Conversion Constant Narrowing Conversion to Float Constant Value Not Known Constraint Mismatch Constraint Number Mismatch Constraint concept Template Constructor Destructor Priority Reserved Constructor Type Mismatch Continue Statement Conversion From Inaccessible Base Class Conversion Function Not Usable Conversion Operator Not Explicit Conversion of Pointer to Member to Function Pointer Conversion of Unbound Pointer to Member to Function Pointer Conversion to Pointer Loses Bits Conversion: Pointer to Incomplete Conversion: Pointer/Integer Conversion: Void Pointer to Object Pointer Converting to Incomplete Class Copy Constructor With Default Argument Cannot Be Defaulted Copy Constructor in Value Class Type Copy Operation Parameter Is Not const Coroutine With Deduced Return Type Coroutine With Ellipsis Parameter Corresponding Declaration Incompatible Corresponding Member Template Is Different Kind Corrupted Export Template File Could Not Open IL File Covariant Override in Managed Class Creating PCH DLL Interface Conflict None Assumed DLL Interface Conflict dllexport Assumed DLL Interface Ignored on Class Template DLL Interface Ignored on Qualified Declaration DLL Interface Requires External Linkage DLL Interface in Unnamed namespace DLL Thread Conflict Dangerous Include File Name Data Member With Interface Type Deallocation Operator in namespace Declaration After Statements Declaration Hides Function Parameter Declaration Hides Template Parameter Declaration Hides catch Parameter Declaration Hides for-init Declaration Incompatible With Previous Use Declaration Modifiers Ignored Declaration Modifiers Incompatible With Previous Declaration Declaration Modifiers Invalid for this Declaration Declaration Should Be of Parameter Declaration With Local Type but Not Defined Declaration With No Linkage Type but Not Defined Declaration in Prototype Scope Declaration of Flexible Array Member Declaration of Reserved Name Declaration of Variable Length Array Declaration of void Ignored Declared but Not Referenced Deduced Return Type Conflict Deduced Return Types Requires C++14 Deduction Failed Deduction Guide Definition Default Argument Already Defined Default Argument Differs in Other Translation Unit Default Argument Expression Not Allowed Default Argument Not at End Default Argument Requires friend to Be Definition Default Argument Used in Parameter Array Function Default Argument for Literal Operator Default Argument on Function Template Not Allowed Default Argument on Member Declaration Default Argument on Member Template Definition Default Argument on Member friend Default Arguments Incompatible Default Association Appears More Than Once Default Constructor Call Not Constant Default Constructor Not constexpr Default Constructor in Value Class Type Default Label Appears More Than Once Default Label Must Be in switch Default Member Initialization Priority for Value Class Default Not Allowed on Partial Specialization Default Template Argument Not Allowed Default-initialization of Reference Defaulted Assignment Cannot Have const Parameter Defaulted Comparison for Property Defaulted Copy Constructor Cannot Have const Parameter Defaulted Default Constructor Cannot Be constexpr Defaulted Functions Requires C++11 Definition of Implicitly Declared Function Delegate Requires Managed Class Delegating Constructor Requires C++11 Delegating Constructor Requires Newer ABI Version Delegation Initialization Priority and Member Initialization Priority Delegation Loop Deleted Default Constructor Deleted Elided Copy Constructor Deleted Function Deleted Function Definition Must Be First Declaration Deleted Function Overrides Nondeleted Function Deleted Functions Requires C++11 Deleted Inherited Definition Constructor Deleted main Dependent Statement Is Declaration Dependent Vector Size Deprecated Access Specifier Deprecated Entity Deprecated String Conversion Derived Class Too Far Designator Is Nonstandard Designator Requires Aggregate Type Designator for Non-POD Designator for Template Dependent Type Destroying delete With Extra Parameters Destroying delete Wrong Type Destructor Name Must Be Qualified Destructor Position Destructor Qualifier Type Mismatch Destructor Type Mismatch Destructor in Value Class Type Destructor or Finalizer With Named Override Different Return Type on Virtual Function Override Different enum Comparison Digit Separators Not Enabled Dimension Not const Unsigned Integer Dual Lookup Ambiguous Name Duplicate Base Class Name Duplicate Calling Convention Duplicate Class Modifier Duplicate Constraint Duplicate Declaration Specifier Duplicate Designator Duplicate File Name Duplicate Function Modifier Duplicate Get or Put Duplicate Header Unit Map Duplicate Inheriting Constructor Duplicate Macro Parameter Name Duplicate Memory Attribute Duplicate Microsoft Attribute Argument Duplicate Module Map Duplicate Parameter Name Duplicate Threads Dimension Duplicate Type Qualifier Duplicate Type in C11 Generic Duplicate asm Qualifier Duplicate friend Declaration Duplicate typedef Duplicate typedef in Class Duplicate using Declaration Dynamic Allocation After Initialization Dynamic Exception Specification Not Permitted Dynamic Exception Specifications Deprecated Dynamic Local static in Statement Expression Dynamic Thread Creation ELF Visibility Pop Mismatch ELF Visibility Stack Empty Element Type Incomplete Ellipsis Ellipsis After Parameter Array Ellipsis CLI Accessor Ellipsis Not Allowed Ellipsis Parameter for Literal Operator Ellipsis on Operator Function Empty Anonymous union Empty Clobbers List Empty Delimited Escape Empty Include Search Path Empty Lambda Template Parameter List Empty Macro Argument Empty Pack Alignment Stack Empty Pack Expansion Empty Property Indices Empty Requires Expression Empty Template Parameter List Empty Then Statement Empty Translation Unit Empty Unicode Name Empty Wide Character Empty else Statement Empty throw Specification Not C++20 Entity Cannot Be Specialized Entity Defined Twice Entity Defined in Other Translation Unit Entity Differs in Other Translation Unit Enumerator Already Declared Equals Assumed in Command Line Macro Definition Error in Debug Option Argument Event Accessor Missing Value Parameter Event Accessor Value Parameter Mismatch Event Name Not Allowed Event Requires Managed Class Event Without raise Invoked Event add Already Declared Event in C++/CX Value Type Event raise Already Declared Event raise Type Mismatch Event remove Already Declared Exception Handler Used Exception Specification Ignored Exception Specification Not Allowed Exception Specification Override Incompatible Exceptions in Embedded C++ Excess Characters in Literal Ignored Excess Initializers Ignored Excess Pack Expansion Excessive Comparison Rewrites Excessive Macro Parameter Evaluation in C Generic Excessive Rescan Depth Excessive Stack Depth Excessive constexpr Complexity Exit upc_forall Expansion Contains No Packs Expected "(" Expected "(" or "{" Expected ")" Expected ")" and #pragma Ignored Expected ":]" Expected "=" Expected "[" Expected "[:" Expected "]" Expected "{" Expected "}" Expected Attribute Name Expected C++ Keyword Expected Class Type Expected Colon Expected Comma Expected Comma or "]" Expected Comma or Greater Than Expected Declaration Expected Definition of Tag Expected Ellipsis Expected Error Argument Expected Field Access Expected Field Name Expected File Name Expected Greater Than Expected Greater Than Not Shift Right Expected Identifier Expected Identifier in for each Declaration Expected Integer Constant Expected Less Than Expected Line Number Expected Macro Parameter Expected Member Name Expected Microsoft Attribute Argument List Expected Microsoft Attribute bool Value Expected Microsoft Attribute enum Value Expected Operator Expected Pointer to Member Expected Primary Expression Expected Push Pop Expected Semicolon Expected Statement Expected String Literal Expected Template Argument Expected Type Name Expected Type Specifier Expected __except or __finally Expected an Attribute Expected asm Clobber Expected asm Label Expected asm Operand Expected asm String Expected auto Expected class Expected class or typename Expected concept Name Expected in Expected on or off Expected string_view Value Expected template Expected while Expired Reflection Value Explicit Instantiation Not in namespace Scope Explicit Lambda Template Parameters Requires C++20 Explicit Narrowing 64 Bit Integer Explicit Specialization Not in namespace Scope Explicit Specialization friend Explicit Template Arguments Ignored Explicit Template Arguments Not Allowed Explicit enum Base Nonstandard in Current Mode Explicit this Defaulted Comparison Explicit this Needs this Explicit this Parameter Must Be First Explicitly Specialized Alias Template Export Cannot Contain Export Export Cannot Contain Import Export Class Members Export Internal Linkage Export Must Introduce Name Export Removed Export Requires Modules Exported Instantiation and Specialized Exported in Unnamed namespace Expression Has No Effect Expression Not Arithmetic Expression Not Arithmetic or Unscoped enum Expression Not Arithmetic or Unscoped enum or Pointer Expression Not Arithmetic or enum Expression Not Arithmetic or enum or Pointer Expression Not Constant Expression Not Fixed Point Expression Not Integral Expression Not Integral Constant Expression Not Integral or Fixed Point Expression Not Integral or Unscoped enum Expression Not Integral or Unscoped enum or Fixed Point Expression Not Integral or enum Expression Not Integral or enum or Fixed Point Expression Not Object Pointer Expression Not Pointer Expression Not Pointer nor Handle Expression Not Pointer or Array Handle Expression Not Pointer to Function Expression Not Pointer to Member Expression Not Pointer to Object Expression Not Pointer to class Expression Not Pointer to struct or union Expression Not Scalar Expression Not a Glvalue Expression Not a Modifiable Lvalue Expression Not an Lvalue Expression Not an Lvalue or Function Designator Expression Not bool Expression Not class Expression Not struct or union Expression Value Widened by Assignment Expression Value Widened by Other Operand Extended Designator Is GNU Extension Extended Friends Requires C++11 Extended Modifier Ignored on enum Extern Array Without Size External Name Clash Extra Arguments Ignored Extra Bits Ignored Extra Braces on Simple Initialization Priority Extra Characters on Number Extra Event Accessor Parameters Extra Property Accessor Parameters Extra Semicolon Extra Text in Preprocessor Directive Extraneous Injected Declaration Tokens Extraneous Injected Member Tokens Extraneous Injected Statement Tokens FILE* Dereference Failed Destructor Constraints Failed Tuple Container Member Get Fallthrough Must Precede switch case Feature Not Allowed in Current Mode Feature Requires C Feature Test Macro Ignored Feature Test Macro Requires Identifier Field Cannot Be Tracking Reference Field Cannot Involve VLA Type Field Initializer Is Not Constant Field Initializers Requires C++11 Field Name Conflicts With Class Field Subobject Not Initialized Field Target on Nontrivial Property or Event Field Type Cannot Be Qualified With Named Address Space Field Uses Tail Padding Field With asm Name Not Allowed Field Without DLL Interface Field initializer_list File Ends With Unterminated Type Definition File for Module Not Found Final Suspend Cannot throw Finalize Does Not Override Object Finalize Finalizer Does Not Exist Finalizer Name Must Be Qualified Finalizer Qualifier Type Mismatch Finalizer Requires Reference Type Finalizer Type Mismatch First Argument Must Be Integer Constant First Declaration Not gnu_inline First inline After Definition Fixed Sign Change Fixed Template Parameter Fixed register Clobbered Fixed register Used Fixed to Fixed Conversion Fixed to Float Conversion Fixed to Integer Conversion Flexible Array Is Nonstandard Flexible Array Member Not Allowed Float Pointer Conversion Float Template Parameter Float to Fixed Conversion Float to Float Conversion Float to Integer Conversion Float-typed Loop Counter Floating Point Domain Error Floating Point Equality Floating Point Range Error Fold Expression Operator Mismatch Fold Expressions Nonstandard Forbidden Function Name in Namespace Format Argument Does Not Exist Format Argument Is Not String Found From Header Unit Map Found From Module Map Fully Qualified Constructor Call Function Defaulted in friend Declaration Function Defined in Header File Function Does Not Match Arguments Function Ineligible Function Modifier Requires Virtual Function Function Modifiers abstract and sealed Function Pointer Function Pointer Conversion Function Qualifier on Constructor or Destructor Function Qualifier on Finalizer Function Qualifier on Nonmember Function Qualifier on new or delete Function Qualifier on static Member Function Returning Abstract Class Function Returning Array Function Returning Function Function Returning Named Address Space Function Returning Shared Function Template Cannot Be Defaulted Function Template Named main Function Too Long Function Type Must Come From Declarator Function Type Not Allowed Function Type Required Function-Like Macro GCC #pragma Nothing to Pop GCC Lvalue Cast Ignored GCC Use of Cast as Lvalue GNU Attribute on Template Redeclaration GNU Attribute on Template Redeclaration but Original Kept GNU C89 --inlining Requires C GNU Extension GNU May Use Bit Padding GNU Multiversion Only One arch= GNU Multiversion default Missing GNU Typeof GNU Virtual Base Gap GNU Visibility Conflict Generated Default Constructor Exception Specification Circularity Generated Default Constructor Used in Field Initializer Generated Exception Specification Override Incompatible Generic Class Cannot Be Custom Attribute Generic Class Must Be Managed Generic Lambda Cannot Capture Generic Parameter Cannot Have Default Generic Parameter Does Not Permit Varargs Generic Parameter Requires __clrcall Generic Selection With Points to Generic Type in Template Argument Generic in Template Global Defined After Nested Type Global Module Fragment Declaration Must Come First Global Module Source Conflict Global Namespace Has No Actual Member Global Qualifier Not Allowed Goto Statement Handle Member in Standard Class Handle of Nonmanaged Handle to Address Type Handle to Array Handle to Function Handle to Standard Class Type Handle to Unscoped enum Type Handle to Value Class Handle to enum Handle to void Handler Redeclares Parameter Header Not Importable Header Unit Creation Failure Hex Floating Point Constant Hidden Anonymous union Field Hidden by Old for-init High Cyclomatic Complexity (Procedure) High Risk Loop IFC Bad Function Definition IFC Bad Function Parameter Counts Multiple Multiple IFC Bad Function Parameter Counts Multiple Single IFC Bad Function Parameter Counts Single Multiple IFC Bad Function Parameter Name IFC Bad Function Parameter Wrong Chart IFC Bad Identifier IFC Entity Reference Failure IFC File Incompatibility IFC Function Template Parse Failure IFC Line Number Overflow IFC Missing Function Definition IFC No Corresponding Calling Conversion IFC No Corresponding Operator IFC Partition Bad Entry Size IFC Partition Mismatch IFC Partition Missing Element IFC Requirement Failure IFC Requirement Failure Fill in IFC Too Few Template Arguments IFC Too Many Template Arguments IFC Unexpected Null Scope Member IFC Unsupported Token IL Display Requires IL File Name IL File Must Be Specified IL File Version Change ILP64 Will Narrow Identifier Already Declared Identifier Can Only Appear in Function Identifier Must Be Class or Type Name Identifier Must Be Class or namespace Name Identifier Not Keyword Ignoring Attribute on Anonymous namespace Ignoring Attribute on Non-inline namespace Imaginary Times Assign Implicit Address of Explicit this Function Implicit Address of Function Implicit Call of Ambiguous Name Implicit Constructor Shadowing Implicit Copy this Capture Deprecated Implicit Encoding in String Concatenation Implicit Fixed Point to Floating Point Conversion Implicit Function Declaration Implicit Inheritance from Stateful Virtual Base Implicit Lambda Capture Implicit Lambda Capture of this Implicit Narrowing 64 Bit Integer Implicit Pointer Type Conversion in Selection of C Generic Implicit Return From Non-void Function Implicit co_return With No return_void Implicit int on main Implicitly Deleted Move Candidate Ignored Import Requires Microsoft Import Skipped Improperly Terminated Macro Call Inaccessible Base Class Inaccessible Destructor Not Invoked Inaccessible Elided Copy Constructor Inaccessible Elided Destructor Inaccessible Rvalue Destructor Inaccessible Special Function Inappropriate Argument to memcmp Inappropriate Assignment Operator Return Inappropriate Assignment Type Inappropriate Association Type in C Generic Inappropriate Bit-field Type Inappropriate Cast Type Inappropriate Cast Type: Expression Inappropriate Character Arithmetic Inappropriate Declaration in Global Namespace Inappropriate Include File Specification Inappropriate Numeric Assignment Inappropriate Operand Type Inappropriate Selection Type in C Generic Inappropriate Test of Error Code Inappropriate Volatile Declaration Include Directory Both System and Nonsystem Include File Without Guard Include Kind Mismatch Incompatible Assignment Operands Incompatible Delegate Object Incompatible Exception Specification Incompatible Exception Specifications Incompatible Language Modes Incompatible Linkage Specifier Incompatible Operands Incompatible Parameter Incompatible Pointer to Member Selection Operands Incompatible Shuffle Mask Incompatible Shuffle Source Operands Incompatible Thread Locality Incompatible Vectors Conversion Incompatible __builtin_complex Types Incompatible enum Base Types Incompatible enum Kinds Incompatible ifunc Resolver Type Incompatible inline Specifier on Specific Declaration Incompatible std::meta::value_of Type Incomplete Class Return Type Incomplete Class Type Incomplete Function Prototype Incomplete Function Return Type Incomplete Return Type Incomplete Type Not Allowed Incomplete User Type Incomplete Variable Type Incomplete enum Bit Field or Bad Opaque enum Inconsistent Alignment Inconsistent Chained Designator Initialization Inconsistent Deduction of auto Inconsistent Enumerator Initialization Inconsistent Macro Parameter Expansion in C Generic Inconsistent std::string_view Inconsistent tls_model Attribute Argument Incorrect Host Identifier Incrementing of bool Deprecated Incrementing of bool Not Allowed Indeterminate Overloaded Function Indirect Anonymous union Designator Indirect Nonvirtual Base Class Not Allowed Ineligible Default Constructor Ineligible Member Function Inexact Fixed Conversion Inexact Fixed-point Conversion Inexact Floating Point Conversion Inheritance Kind Already Set Inheritance Kind Ignored on enum Inherited Member Not Allowed Inheriting Constructor Ignored for Copy Inheriting Constructor Not From Direct Base Inheriting Constructor Requires C++11 Initialization Needing Temporary Not Allowed Initialization Not Reachable Initialization Priority List Element Type Not Complete Object Initialization Priority Priority Reserved Initialization Priority Statement in Range for Nonstandard Initializer Differs in Other Translation Unit Initializer Not Allowed on Array new Initializer Not Constant Initializer in Parameter Initializers Incompatible Inline Function Not static Instantiation Option Requires C++ Instantiation Requested No Definition Supplied Instantiation Requested and Specialized Insufficient enum Range Integer May Not Fit in Fixed Point Result Integer Overflow Integer Overflow Class Internal Integer Overflow Internal Integer Pack Element for Template Integer Pack Element for Type Integer Sign Change Integer Too Large Integer Truncated Integer to Fixed Conversion Integer to Float Conversion Interface Cannot Be Local Interface Cannot Be Nested Class Interface Cannot Have Constructor or Destructor Interface Cannot Have Data Member Interface Cannot Have Member Generics Interface Cannot Have Member Templates Interface Cannot Have Operator Interface Cannot Have Virtual Base Interface Cannot Have friend Interface Cannot Have private or protected Interface Cannot Have static Members Interface Cannot Have typedef Interface Must Derive From Interface Interface Non-static Data Member Interface Not Implemented Intrinsic Name Released Intrinsic Requires Template Instance Invalid #import Directory Invalid #pragma Conform Kind Invalid Access Specifier Invalid Alignment Reducing Attribute Invalid Argument to Attribute Invalid Assignment Operator to Be Defaulted Invalid Attribute Location Invalid Attribute Target for Microsoft Attribute Invalid Attribute Target for Standalone Microsoft Attribute Invalid Base for Microsoft Attributes Invalid Bit Cast Type Invalid CWD Invalid Character Invalid Character in Unicode Name Invalid Cleanup Routine Invalid Constraint Invalid Constructor to Be Defaulted Invalid Declaration Invalid Default Argument Invalid Delegate Type Invalid Designator Kind Invalid Destructor Name Invalid EDG Base Directory Invalid Empty Attribute Argument List Invalid Empty Fold Expression Invalid Empty Initializer List Invalid Entity for Pending Constraint Invalid Enumerator Value Invalid Error Limit Invalid Error Number Invalid Error Tag Invalid Event Accessor Declaration Invalid Event Handler Type Invalid Event Type Invalid Event Use Invalid Explicit Exception Specification Invalid Finalizer Name Invalid Flag Name Invalid Float Parameter for Literal Operator Invalid Fold Expression Operator Invalid Function to Be Defaulted Invalid GNU Version Invalid GNU __sync Size Invalid Generic Argument Invalid Generic Specialization Invalid IDisposable Dispose Invalid IFC Partition Invalid IFC Position Backtrace Field Invalid IFC Position Backtrace Position Invalid IFC Sort Value Invalid Identifier Start Universal Character Name Invalid Identifier Universal Character Name Invalid Inheritance Kind for Class Invalid Initialization Priority Statement Invalid Instantiation Argument Invalid Instantiation Directory Invalid Instantiation Mode Invalid Integer Kind Invalid Integer Parameter for Literal Operator Invalid Interface Class Base Invalid Kind Invalid Link Scope Invalid Literal Operator Identifier Invalid Literal Type Invalid Locale Invalid Macro Definition Invalid Macro Undefinition Invalid Member Constant Type Invalid Microsoft Attribute Name Invalid Microsoft Attribute Target Invalid Microsoft Attribute enum Value Invalid Microsoft Attribute uuid Value Invalid Microsoft Version Invalid Misaligned IFC Position Invalid NEON Polyvector Element Type Invalid NEON Vector Element Type Invalid NEON Vector Size Invalid Name After template Invalid Nested Class Redeclaration Invalid Nontype Template Argument Invalid Number Invalid Object Finalize Invalid Operator in Requires Clause Invalid Option Invalid Output Mode Invalid Overflowing IFC Position Invalid PCH Directory Invalid PCH File Invalid PCH Size Invalid Parameter Array Type Invalid Parameter Type for Literal Operator Invalid Parameter for Literal Operator Template Invalid Placeholder for Defaulted Spaceship Return Invalid Pointer Parameter for Literal Operator Invalid Previous Declaration Iterator Invalid Property Accessor Declaration Invalid Reference Class Base Invalid Reference Tracking Reference Combination Invalid Reflection Equality Invalid Reflection for Intrinsic Invalid Scalable Vector Element Type Invalid Scalable Vector Tuple Elements Invalid Scoped enum Elaboration Invalid Second Parameter Type for Literal Operator Invalid Selective Overrider Declaration Invalid Spaceship Types Invalid Specific Reference Class Base Invalid Specifier for Deduction Guide Invalid Standard Comparison Type Invalid Standard Comparison Value Invalid Start of Member Declaration Invalid Start of Requires Clause Expression Invalid Statement in constexpr Constructor Invalid Statement in constexpr Function Invalid Storage Class in for-init Invalid String Literal Operator Template Invalid Structured Binding Specifier Invalid Structured Binding Syntax Invalid Structured Binding Type Invalid Symbolic asm Operand Name Invalid Target Invalid Template Directory Invalid Template Parameter for Literal Operator Template Invalid Token After template Invalid Type Constraint Invalid Type Pointed to for interior_ptr or pin_ptr Invalid Type for Builtin Invalid Type for Nullability Invalid Type for __w64 Invalid Universal Character Name Invalid Unrepresentable IFC Position Invalid Use of Custom Microsoft Attribute Invalid Use of Microsoft Attribute Invalid Use of Standalone Custom Microsoft Attribute Invalid Use of Standalone Microsoft Attribute Invalid Use of concept Invalid User-defined Literal Value Invalid Value Class Base Invalid Variable main Invalid Vector Element Type Invalid _Pragma operator Invalid __INTADDR__ Address Invalid __builtin_fpclassify Arguments Invalid __pragma operator Invalid asm Qualifiers Invalid case Range Invalid clang Version Invalid co_return Invalid concept Identifier Invalid concept Redeclaration Invalid consteval Invalid constexpr Invalid constexpr Body Invalid constexpr memcmp Invalid constinit Invalid gcnew Type Invalid mmap Address Invalid noexcept Specifier Operand Invalid sentinel Argument Invalid std::initializer_list Parameter List Invalid std::meta::infovec for Reflection Invalid std::string_view for Reflection Invalid std::tuple_size Invalid target Attribute Invalid typename Specifier Is Constant Evaluated in Constant Expression Is Constant Evaluated in Non-constexpr Context Is Constant Evaluated in consteval Context K&R Mode Field Ambiguity Keyword Dropped Known Comparison With Null Label Not In Enclosing Block Label Operand Number Out of Range Label in constexpr Function Labeled Declaration Lambda Capture Involves Variable Length Array Lambda Capture Structured Binding Lambda Captures Handle or Tracking Reference Lambda Captures Managed Class Type Lambda Has No Parameter List Lambda Has No Return Type Lambda Not Allowed Here Lambda Not Constant Expression Lambda Without Parameters Nonstandard Lambda Without Parameters Requires Clause Lambda in noexcept Specifier Lambda mutable and static Lambdas Requires C++11 Last Line Backslash Last Line Incomplete Leading Character Ignored in Character Literal Leftover Debug Code Likely Unlikely Conflict Line Splicing in Comment Link Scope Relaxation Link Scope Requires External Linkage Linkage Conflict Linkage Specifier Not Allowed Linkage main List Initialization Priority of Incomplete List Initializer Nonstandard in Current Mode List Macros Incompatible With Multiple Translation Units List Make Dependencies Incompatible With Multiple Translation Units Literal Fields Disallowed in C++/CX Mode Literal Operator Not Found Literal Requires Managed Class Literal Suffix No Underscore Literal Without Initializer Literal const Has No Effect Local #pragma pack Local CLI Managed Class Type Local Class Function Definition Missing Local Class friend Requires Prior Declaration Local Class in Managed Member Function Local Conflicts With auto Instantiation Local Function Attribute Ignored Local Lambda in Managed Member Function Local Named register Initializer Not Allowed Local Type Used in Exception Local Type in Function Local Type in Nonlocal Variable Local Type in Template Argument Local Variable Hidden Lock/Unlock Mismatch Lone Flexible Array Member Long Lifetime Temporaries Incompatible With Newer Features Loop Not Reachable Lossy Conversion Lower Case in Hexadecimal Literal MYTHREAD Constant Not Allowed Macro Argument is both Mixed and Expanded Macro Defined in Function Body Macro Defines Constant Macro Definition of Reserved Name Macro Does Not End With } or ) Macro Does Not Start With { or ( Macro Name is C Keyword Macro Not User-defined Literal Suffix Macro Parameter Not Parenthesized Macro Recursion Macro Undefined in Function Body Macro Undefinition of Reserved Name Macro Uses # Operator Macro Uses ## Operator Macro Uses -> Operator Macro Uses Unary * Operator Macro Uses [] Operator Macro in Preprocessor Directive Malformed #include Malformed Universal Character Malformed for-loop Condition Malformed for-loop Initialization Malformed for-loop Step Malformed switch Statement Managed Base for Standard Class Managed Class Cannot Have friend Managed Class Type Cannot Have private or protected Base Managed Member Exception Specification Managed Member Function Cannot Have Ellipsis Parameter Managed Object Not Caught by Handle Managed Object Not Thrown by Handle Managed nullptr Not Allowed Mangled Name Too Long Mangling for requires Match Limit for Symbolic asm Operand Maximum constexpr Option Requires C++ Member Access Requires Pointer Member Already Initialized Member Cannot Have Internal Linkage Member Constant Not const Member Function Call on initonly Field Member Function Could Be const Member Function Could Be static Member Function Modifier on Template Member Function Modifier on static Member Member Function Redeclaration Member Function Redeclaration Outside Class Member Name Reserved by CLI operator Member Name Reserved by Property Member Partial Specialization Not in namespace Member Reference Requires Object Member Special After Class Definition Member using Must Be Visible in Direct Base Memory Attribute Ignored Memory Attribute Incompatible Memory Attribute May Not Precede Nested Declarator Memory Mismatch Method Default Value Mismatch Microsoft Attribute Not Allowed Microsoft Extension Microsoft IFC Unavailable Microsoft Metadata Initialization Priority Failed Microsoft Parenthesized Member Microsoft Pointer Sign Extension Microsoft Pointer Signedness Conflict Microsoft Pointer Signedness Must Follow Star Microsoft Pointer Signedness on Pointer to Member Microsoft Pointer Width Conflict Microsoft Pointer Width Must Follow Star Microsoft Version Does Not Support C++14 Mode Microsoft Version Does Not Support C++17 Mode Microsoft Version Does Not Support C++20 Mode Microsoft Version Does Not Support C++23 Mode Microsoft Version Does Not Support C++latest Mode Microsoft inline Not Allowed Here Mismatched Argument Types Mismatched Function for Delegate Mismatched Operand Types Mismatched Shared Block Size Misplaced Default Association in C Generic Misplaced Digit Separator Misplaced Return Statement Misplaced Using Declaration Misplaced case Misplaced default Missing != on Range-based for Type Missing != on for each Type Missing Access Specifier Missing Argument Missing Attribute Arguments Missing Attribute in Other Translation Unit Missing Attribute namespace Missing Base Class or Member Name Missing Bindings Missing Braces in Initialization Missing Class Definition Missing Constraint Letter Missing Declaration Specifiers Missing Default Constructor on Unnamed const Missing Default Constructor on const Missing Delegate Object Missing Exception Declaration Missing External Declaration Missing External Definition Missing Final else Missing Floating Point Type Missing GNU std::source_location Type Missing Handler Missing Header Unit Map Missing Increment on Range-based for Type Missing Increment on for each Type Missing Indirect on Range-based for Type Missing Indirect on for each Type Missing Initializer Missing Initializer List Missing Initializer on Fields Missing Initializer on Fields With constexpr Constructor Missing Initializer on Reference Missing Initializer on Unnamed const Missing Initializer on const Missing Label Operand Number Missing Lambda Body Missing Literal Suffix Missing Lock Acquisition Missing Lock Release Missing Named register Storage Class Missing Parentheses Missing Raw String Delimiter Missing Raw String Delimiter "(" Missing Source File Name Missing Template Argument List Missing Template Parameter Missing Template Parameter List Missing Test of Error Code Missing Trailing Return Type Missing Type Specifier Missing User-defined Operations Missing __VA_OPT__ Parenthesis Missing __implements List Missing add or remove Accessor Missing break Missing const Assignment Operator Missing const Copy Constructor Missing constinit Missing default Missing delete Missing finally Missing for-loop Step Missing for-loop Termination Missing get and set Accessors Missing gnu_inline Attribute on Redeclaration Missing initializer_list Constructor Missing namespace Name Missing noreturn Specifier Missing override Attribute in base_check Class Missing std::tuple Element Missing std::tuple Element Instance Missing target Attribute Missing typedef Name Mixed Assembly and Code Mixed Encodings in String Concatenation Mixed Vector Scalar Operation Mixed enum Type Mixed enum Type Anachronism Mode Incompatible With Type Modification of Standard Namespaces Modification of initonly Field Modification of static initonly Field Modified Class Template Placeholder Modified Parameter Modified __auto_type Modified decltype(auto) Type Modifier Not Allowed on Destructor Modifier Not Allowed on Finalizer Module Already Imported Module Cannot Depend on Itself Module Declaration Only After Global Module Module File Contains Unsupported Constructs Module File Mismatch Module File Not Found Module Import Conflict Module Read Error Module Requires Primary Name Module Use With export Template Module Use in Multiple Translation Unit Mode Modules Not Enabled More Than One Capture More Than One Fragment Declaration More Than One Module Declaration Move Constructor With Copy Semantics Move Constructor or Assign Copy of Lvalue Move Operations Require Rvalue References Multicharacter Literal Multicharacter User-defined Literal Multiple Abnormal Loop Exits Multiple Attribute Namespaces Multiple Block Sizes Multiple Class Constraints Multiple Constraint Clauses Multiple Declarations On Line Multiple Declarations of a Global Multiple Explicit Instantiations Multiple External Declarations Multiple External Definitions Multiple Header Map Matches Multiple Inheritance in Embedded C++ Multiple Inheritance with Private Interface Class Multiple Inheritance with Protected Interface Class Multiple Inheritance with Public Base Class Multiple Inheritance with Too Many Protected Base Classes Multiple Link Scope Specifiers Multiple Module Matches Multiple Named Address Spaces Multiple Nested Types Multiple Overrides Multiple Return Statements Multiple Statements On Line Multiple Storage Classes Multiple Template Declarations Not Allowed Multiple Thread-local Storage Specifiers Multiple Visibility Specifiers Multiple __declspec(align(...)) Multiple union Designators Multiple union Field Initializers Multiple union Field Initializers Empty Must Be Prototype Instantiation Must Be _Atomic Qualified Type Must Introduce Attribute Must Specify C++11 Mode Must Specify C++14 Mode NULL Used as Integer Name Before typeid Not Type Name Linkage Mismatch for Variable Name Lookup Bug Name Must Be Prototype Instantiation Name Not Class in File Scope Name Not Found in File Scope Name Not Member of Class or Base Classes Name Not Tag in File Scope Named Address Space Not Allowed Named Address Space for Parameter Named Address Space on Function Type Named Module Source Conflict Named Override Requires Managed Type Named Override Requires virtual Named Override Type Mismatch Named register Not Allowed Namespaces in Embedded C++ Naming Style Violation Narrowing Conversion Negative Shift Count Negative Value Nested Class Anachronism Nested Comment Nested Conditional Operator Nested Function Declaration Nested Locks Nested __VA_OPT__ Nested inline namespace Nonstandard Nested namespace Nonstandard Nested upc_forall Never Defined No Access or using Declaration in union No Access to Name No Access to Type Cfront Mode No Alignment on Definition No Appropriate delete No Array Designators in C++ Mode No Array new and delete Support No Chained Designators With Destructor No Chained Designators in C++ Mode No Class Template Guide No Classification for Fixed Point Type No Common Type No Constructor but const or Reference Member No Constructor for Conversion No Constructor or Destructor using Declaration No Conversion Function No Corresponding Member delete No Corresponding Push No Corresponding delete No Default Constructor No Default delete in Virtual Destructor No Designator Value No Exception Support No Export Support No Finalizer using Declaration No Float128 No Float80 No GNU Virtual Base Gap No Implicit Capture on Enclosing Lambda No Internal Linkage for new or delete No Match for Address of Overloaded Function No Match for Type of Overloaded Function No Match in C11 Generic No Matching #endif No Matching #if No Matching Arity No Matching Constructor No Matching Function No Matching Function Due to Selector No Matching Operator Function No Matching forScope Stack Entry No Matching new Function No Matching target Attribute No Mixed Initialization Priority in C++ Mode No Named Fields No Named register for Array No Negative Designator Range No Ordinary and Extended Designators No Out of Order Initialization Priority in C++ Mode No Output File Needed No Overloaded Subscript With offsetof No Overrider for Pure Virtual Function No Pack Expansion in Designator No Pack in Fold Expression No Packing of Non-POD Field No Parameter for Literal Operator No Parameters With Class Type No Parameters With Class or enum Type No Pointer Parameters No Previous Declaration No Prior Declaration No Prior push_macro No Qualified friend Definition No Range Designator With Dynamic Initializer No Suitable Assignment Operator No Suitable Copy Constructor No Suitable Synthesis Assignment Operator No Type of Specified Width No User Defined Conversion No Value Returned in Non-void Function No Viable delete for Coroutine No abi_tag on Declaration No char16_t Representation No constexpr Coroutine No get Property No mutable Allowed on Anonymous union No nothrow Global new for Coroutine No put Property No return_value and return_void No sentinel Argument No typename in friend Class Declaration Non-Boolean Preprocessor Expression Non-POD Passed to Ellipsis Non-POD va_arg Non-bool Atomic Constraint Non-const Defaulted Member Comparison Non-const Global Variable Non-const Local Static Variable Non-const Predicate Function Object Non-const Reference Initializer Anachronism Non-const Reference Initializer From Rvalue Non-const String Literal Non-consteval Overrides consteval Non-constexpr Call in Member Initializer Non-constexpr Member Initialization Priority Constructor for constexpr Constructor Non-distinct Identifiers: External Names Non-distinct Identifiers: Macro/Macro Non-distinct Identifiers: Macro/Other Non-distinct Identifiers: Nested Scope Non-distinct Identifiers: Same Scope Non-final Class has Non-Virtual Public Destructor Non-static Address of Operator in Managed Class Non-static Member Definition Not Allowed Non-unique Identifiers: External Name Non-unique Identifiers: Internal Name Non-unique Identifiers: Tag Non-unique Identifiers: Typedef Non-zero Error Code Non-zero Error Code Assignment Nonarithmetic Operation in Template Argument Nonautomatic Variable in constexpr Function Nonautonomous Opaque enum Declaration Nonconstant Field Initializer in Member Initializer Nonconstant Member Initialization Priority for constexpr Constructor Nonconstant Splicer Operand Nonconstant enable_if Attribute Nonconstant offsetof Nondefining friend Requires Clause Nondeleted Function Overrides Deleted Function Nonexternal Entity in Template Argument Nonintegral Operation in Template Argument Nonintegral Shuffle Mask Nonliteral Parameter Type in constexpr Function Nonliteral Return Type in constexpr Function Nonliteral Variable in constexpr Function Nonlocal Label Reference Nonlocal VLA Not Allowed Nonmanaged Function for Delegate Nonmember Operator Not Allowed Nonmember Reflection for Intrinsic Nonmember enum Template Nonobject Pointer Arithmetic Nonpublic Data Member in Public C++/CX Value Type Nonpublic Implicit Interface Match Nonscalar Vacuous Destructor Call Nonshared Strict Relaxed Nonshared upc_blocksizeof Nonstandard Address of Ellipsis Nonstandard Address of Label Nonstandard Anonymous union Qualifier Nonstandard Array Cast Nonstandard Array With Flexible Array Element Nonstandard Assigned goto Nonstandard Bit Field Initializer Nonstandard Bit Field Type Nonstandard Braces Nonstandard Character at Start of Macro Definition Nonstandard Conversion From Scoped enum Nonstandard Conversion for Cleanup Nonstandard Default Argument Nonstandard Default Argument on Function Template Redeclaration Nonstandard Ellipsis Only Parameter Nonstandard Explicit bool Nonstandard Extra Comma Nonstandard Fixed Point Suffix Nonstandard Forward Declaration enum Nonstandard Ignored Array Cast Nonstandard Implicit Integer Nonstandard Lambda Attributes Nonstandard Long Float Nonstandard Long Long Nonstandard Member Function Address Nonstandard Old Specialization Nonstandard Opaque enum Declaration in Type Identifier Nonstandard Parenthesized String Initializer Nonstandard Pointer Minus Pointer Nonstandard Preprocessor Directive Nonstandard Qualified void Parameter List Nonstandard Qualifier in Global Scope Declaration Nonstandard Qualifier in namespace Member Declaration Nonstandard Secondary Declaration Specifiers Nonstandard Template void Parameter List Nonstandard Unnamed Field Nonstandard Unnamed Member Nonstandard Use of Explicit Default Constructor Nonstandard asm Function Nonstandard const Member Nonstandard const Member Declaration Not Allowed Nonstandard friend Declaration Nonstandard reinterpret_cast Nonstandard void Parameter List Nonthread Local Follows Thread-local Nonunicode Character in Header Nonunicode Character in Identifier Nonvalue Class Type Cannot Be Value Class Member Nonviable Because Argument Mismatch Nonzero Integer Conversion to Pointer Normal Reference Bound to C++/CX Lvalue Normal Reference Bound to Garbage Collected Lvalue Not All Warnings Are Enabled Not Captured Local Variable in Lambda Not Captured this in Lambda Not Class Member Not Compatible With Previous Declaration Not Compatible With Template Template Parameter Not Enough Assertions Not Enough Preallocated Memory Not Found on Pack Alignment Stack Not Generic Parameter of Current Declaration Not Global namespace Not Instantiatable Entity Not Used in Partial Specialization Argument List Not Used in Template Function Parameters Not a Base Class Member Not a Class Template Not a Class or struct Name Not a Field Not a Field Name Not a Field or Base Class Not a Generic Parameter Not a Line Splice Not a Member Not a Member Class Not a Tag Member Not a Template Not a Template Name Not a Type Member Not a Type Name Not a Type Reflection Not a Variable Not an Actual Member Not an enum Type Not an enum Type Name Null Argument for nonnull Parameter Null Character Ignored Null Character in Header Name Null Character in String Null Reference Object Defined in Header File Object Not Initialized Object Slicing Octal Constant Offset in Non-POD Nonstandard Old Fashioned Assignment Operator Old Fashioned Field Selection Old Fashioned Initializer Old Fashioned Pointer Field Selection Old Specialization Not Allowed Old Style Incompatible Parameter Old Style Parameter List Omitted Exception Specification Omitted Exception Specification on Specialization Only Applies to Float Types Only GNU Attributes Here Operand Must Be Real Floating Value Operand Must Be Vector Operation May Not Fit in Fixed Point Result Operator Name Not Allowed Operator Not Allowed After new Out of Class Initializer Ignored Out of Memory During PCH Allocation Out of Order Member Initializers Output File Incompatible With Multiple Inputs Overloaded Function Linkage Override Name Is Destructor or Finalizer Override Name Must Be a Base Class Member Function Override Name Nonvirtual Override With Constraint Mismatch Override With Trivial Property or Event Override of Non-Virtual Method Override of Sealed Function Overriding Reduces Accessibility in Managed Type PCH Command Line Option Mismatch PCH Current Directory Changed PCH File Cannot Be Created PCH File Incomplete PCH File Not Found PCH File Prefix Mismatch PCH Header Files Have Changed PCH Incompatible With Multiple Inputs PCH Must Be First PCH Not Directory PCH hdrstop Cannot Be Found Pack Expansion for Field Member Initialization Priority Pack Initialization Priority Capture Not Enabled Pack Initialization Priority Capture Requires C++20 Pack Initialization Priority Capture in Nonvariadic Context Pack Length Mismatch Pack Not Expanded Pack Not Last Argument Parameter Array on Operator Function Parameter Cannot Be Completed Parameter Identifier List Needs Function Definition Parameter Is Abstract Parameter Is Incomplete Parameter Not Allowed Parameter Pack Cannot Have Default Parameter Pack Declaration Not Allowed Parameter With Interface Type Parameter With Link Scope Specifier Parameter is const Reference to Smart Pointer Parenthesized Initialization Priority Not Allowed Partial Override Partial Specialization After Instantiation Ambiguous Partial Specialization Argument Depends on Template Parameter Partial Specialization Is Primary Template Partial Specialization Not Allowed Partially Uninitialized Aggregate Partially Uninitialized Array Paste Cannot Be First Paste Cannot Be First in __VA_OPT__ Paste Cannot Be Last Paste Cannot Be Last in __VA_OPT__ Period Used as Qualifier Placeholder Type Failed Constraint Placement new Refers to Nonplacement delete Pointed-to Type Could Be const Pointer Arithmetic Pointer Before Beginning of Object Pointer Conversion Loses Bits Pointer Conversion to Same Size Integer Pointer Conversion to bool Pointer Function Pointer Data Conversion Pointer Handle or Reference to Generic Parameter Pointer Handle or Reference to interior_ptr Pointer Handle or Reference to pin_ptr Pointer Incomplete throw Pointer Outside Base Object Pointer Past End of Object Pointer Type Inside Typedef Pointer or Reference to CLI Array Pointer or Reference to Incomplete Type Pointer or Reference to Qualified Function Type Pointer to Member Call Object Not Lvalue Pointer to Member Call Object Not Rvalue Pointer to Member Cast to Pointer to Function Pointer to Member Conversion to bool Pointer to Member Derived Class From Virtual Base Pointer to Member Virtual Base From Derived Class Pointer to Member of Handle Type Pointer to Member of Incomplete Class Pointer to Member of Managed Class Pointer to Member of Reference Type Pointer to Member of Type void Pointer to Member of VLA Type Pointer to Member typedef Pointer to Non-const for Literal Operator Pointer to Reference Pointer to Reference or Interface Class Pointer to Variably-modified Array Type Positional After Named Positional Format Specifier Zero Potential Timebomb Potential Unbounded Loop Predeclared Function Cannot Be Deleted Predefined Macro Redefined Preprocessing Directives in Macro Argument Preprocessor Output Incompatible With Multiple Translation Units Previous Namespace Not inline Previous Namespace inline Previous Non-consteval Declaration Conflict Previous Non-constexpr Declaration Conflict Previous consteval Declaration Conflict Previous constexpr Declaration Conflict Private Module Fragment Only After Module Private Virtual Member Function Not sealed Probable Guiding friend Probable Inadvertent "#" Digraph Probable Inadvertent "[" Digraph Program Entity Too Large for PCH Program Too Large Promise Type Returns Return void Property Name Not Allowed Property Requires Managed Class Property get Already Declared Property get Cannot Have Parameter Property get Index Type Mismatch Property get Index Type Missing Property set Already Declared Property set Index Type Mismatch Property set Index Type Missing Property set Missing Value Parameter Property set Value Parameter Mismatch Protected Access Problem Prototype Lost Public Data Member in Public Nonvalue Type Public Nested Type in C++/CX Type Public Nondata Member in Public C++/CX Value Type Pure Specifier on Nonvirtual Function Pure Specifier on Sealed Member Pure Virtual Definition Pure Virtual Function Pure Virtual Member Template Qualified CLI Accessor Qualified Name Not Allowed Qualified Name Required Qualified Reference Type Qualified Unnamed Bit Field Type Qualified void Return Type Qualifier Dropped in Reference Initializer Qualifier Ignored on Local Declaration Qualifier Must Be Base Class Qualifier Not Allowed on Managed Member Function Qualifier in Member Declaration Qualifier in namespace Member Declaration RTTI in Embedded C++ Raises FE_INVALID Range-based for Incomplete Array Type Range-based for Missing Function Range-based for No Matching Overload Range-based for Nonstandard Range-based for Undefined Identifier Real Imaginary Conversion Recursion Recursive Definition Argument Instantiation Recursive Initializer Instantiation Recursive Instantiation of Template Default Argument Recursive Macro Redeclaration Adds DLL Interface Redeclaration Changes Access Redeclaration of Condition Declaration Name Redeclaration of Range Iterator Redeclaration of Template Parameter Name Redeclaration of for-init Declaration Name Redeclaration of friend With Default Arguments Redefinition After #hard_define Redundant Exception Specification Type Reference Bound to initonly Field Reference Class Has Multiple Reference Bases Reference Class Not Satisfied Reference Class initonly Field Reference Declared mutable Reference Member Suppresses Copy Assignment Declaration Reference Not Allowed in union Reference Qualifier Ignored Reference Qualifier Nonstandard Reference Qualifier Not Allowed Reference Type Not Allowed Reference or Interface Class Member in Standard Class Reference to Nested Function Variable Reference to Reference Reference to Reference or Interface Class Reference to void Reflection of Overloaded Set Register Keyword Relaxed Abstract Checking Requires C++ Relaxed constexpr Requires bool Requested Size Too Large Requires Clause Argument List Substitution Failed Requires Expression Ellipsis Parameter Requires Incompatible With Previous Declaration Reserved Dispose Reserved Enumerator Name Reserved Finalize Resolver Routine Required Restrict Qualifier Used Return From Constructor Function try Block Handler Return From finally Return Reference Initializer Requires Temporary Return Type Cannot Distinguish Functions Return Type Is Interface Return Type of Default Comparison Must Be bool Return Type on Constructor Return Type on Conversion Function Return Type on Destructor Return Type on Finalizer Returning Pointer to Local Temporary Returning Pointer to Local Variable Returning Reference to Local Variable Risky Integer Promotion Runaway Recursive Instantiation Rvalue Defaulted Member Comparison Rvalue Reference Bound to Lvalue Rvalue Reference Template Parameter Rvalue Reference catch Type Rvalue Reference in Exception Specification Rvalue References Option Requires C++ Rvalue References Requires C++11 SFINAE Requires Newer ABI Version STDC #pragma Not Allowed Here SVR4 Token Pasting Comment Same Parameter Types With Different Exception Specifications Same Parameter Types With and Without Reference Qualifiers Scope Could Be File Static Scope Could Be Local Static Scoped enum Nonstandard in Current Mode Scoped enum Operation Type Mismatch Sealed Base Class Sealed CLI Interface Sealed Constraint Secondary Specifier Ignored Selection Initializer Nonstandard Self Friendship Set but Not Used Shared Affinity Type Shared Block Size Must Be Positive Shared Block Size Too Large Shared Inside struct Shared Nonthreads Dimension Shared Parameter Shift Count Too Large Show #pragma Conform forScope Is Nonstandard Show #pragma Conform forScope Is Standard Side Effects in C Generic Selection Side Effects in Expression with Decrement Side Effects in Expression with Increment Side Effects in Initializer List Side Effects in Logical Operand Side Effects in sizeof Signed One Bit Field Signed Unsigned Comparison Similar typedef Simple Incompatible Parameter Single Argument Postfix Increment/Decrement Anachronism Size Affected by Tail Padding Sizeless Type Not Allowed Skipped Inaccessible Function Special Class Template Not Found Special Member Coroutine Specialization Follows Parameter List Specialization Out of namespace Specialization of Called inline Template Function Specialization of Unscoped enum Splice Is Not a Member of Class Standard Array Member in Managed Class Standard Attributes Require C++11 Standard Class Member in Managed Class Standard Class Nested in Managed Class Star this Capture Nonstandard Star this Not Constant Valued Statement Expression Is GNU Extension Statement Expression With VLA Type Statement Expression in Default Argument Statement Expression in Function Only Static Assertion Failed Stop Map Region Ignored Storage Class Not Allowed Storage Class Not Allowed in Specialization Storage Class Not First Storage Class Requires Function or Variable Storage Class in friend Declaration Storage Specifier Ignored Stray Carriage Return Strict Mode Forbids Treating Namespace std as Global Namespace Strict Mode Incompatible With Anachronisms Strict Mode Incompatible With Cfront Strict Mode Incompatible With K&R Mode Strict Mode Incompatible With Long Preserving Strict Mode Incompatible With Microsoft Strict Mode Incompatible With SVR4 Strict Mode Incompatible With Sun String Literal Cannot Initialize Flexible Array Member Structured Binding Incomplete Type Structured Binding Lambda Structured Binding Restricted Storage Class Structured Binding Storage Class Structured Binding Template Structured Binding Undefined Identifier Structured Binding With Multiple Declarators Structured Binding consteval Structured Binding constexpr Structured Binding in Condition Structured Binding inline Structured Binding of Private Member Structured Bindings Requires C++17 Subobject Copy Assignment Declaration Suppressed Subobject Copy Constructor Declaration Suppressed Subscript Mechanism Conflict Subscript Out of Range Substitution Argument Is Not Variable Sun Incompatible With Cfront Sun Mode Requires C++ Superfluous Delegate Object Suppressed Destructor Needed Suppressed Module Error Diagnostic Suppressed Module Errors Diagnostic Suppressed Module Warning Diagnostic Suppressed Module Warnings Diagnostic Suspicious Comment Formatting Suspicious String Formatting Symbol Not a Class Template Symbol Not a Template Symbol Not a Type Name Symmetrical Operator Member Function Tag Defined in constexpr Body Tag Kind Incompatible With Declaration Tag Kind Incompatible With Template Parameter Taking Address of Temporary Target String Must Be Narrow Target Unmatched Parentheses Task Delay Function Template Argument Cannot Point to Subobject Template Argument Index Out of Bounds Template Constraint Not Satisfied Template Delegate Template Dependent Designator Template Depth Mismatch Template Identifier Not Allowed Template Instance Already Used Template Missing Closing Brace Template Parameter Has Class Type Template Parameter Has Nonstructural Class Type Template Parameter List Not Allowed Template Parameter List Too Long Template Parameter Pack Not at End Template Parameter in Elaborated Type Template Template Parameter Same Name as Template Parameter Template and Instance Linkage Conflict Template friend Definition Not Allowed Template in Generic Template in Managed Class Template operator delete Template operator new Templates in Embedded C++ Temporary Used for Reference Initializer Terse static_assert Not Enabled Thread-local Follows Nonthread Local Thread-local Ignored Thread-local Must Include static or extern Thread-local Not Allowed Threads Constant Not Allowed Threads Dimension Requires Definite Block Size Too Few Arguments Too Few Arguments for Operator Too Few Array Bounds Too Few Cases in switch Too Few Generic Arguments Too Few Macro Arguments Too Few Template Arguments Too Few Template Parameters Too Few printf Arguments Too Large to inline Too Many Alignment Specifiers Too Many Arguments Too Many Arguments Provided for Attribute Too Many Arguments for Conversion Too Many Arguments for Operator Too Many Array Bounds Too Many Cast Operands Too Many Characters Too Many Constraints Too Many Dereferences Too Many Generic Arguments Too Many Initializer Values Too Many Macro Arguments Too Many Microsoft Attribute Arguments Too Many Named Address Space Too Many Parameters Too Many Parameters for Destructor Too Many Parameters for Finalizer Too Many Parameters for Literal Operator Too Many Side Effects in Assignment Too Many Side Effects in Condition Too Many Side Effects in Function Call Too Many Side Effects in Statement Too Many Side Effects in Switch Too Many Structured Bindings Too Many Template Arguments Too Many Template Parameters Too Many Unused Instantiations Too Many Virtual Functions Too Many printf Arguments Too Much Indirection in Declaration Tracking Reference Member in Standard Class Tracking Reference to Constant Tracking Reference to Delegate Tracking Reference to Function Tracking Reference to System String Tracking Reference to Value Class Tracking Reference to enum Trailing Requires Clause Not on Template Trailing Requires on Virtual Function Trailing Return Type Function Without Simple auto Trailing Return Type Requires auto Trailing Return Type in Nested Declarator Transparent Attribute Ignored Transparent Type Is Not union Transparent union Cannot Have Bit Field First Transparent union Cannot Have Floating First Field Trigraph Trigraph Ignored Trivial Division By Zero Trivial Indexed Property Trivial Reference Property Trivial const or volatile Property Tuple Get No Matching Overload Tuple Index Overflow Two Packs in Fold Expression Type Cannot Be Class Member Type Cannot Be Parameter Name Type Constraint Failed Type Constraint Requires Type concept Type Declaration in Anonymous union Type Definition Not Allowed Type Definition Not Allowed in Function Type Declaration Type Generic Function Mismatch Type Identifier Not Allowed Type Is Declared abstract Type Is Interface Type Must Be Integral Type Must Be Object Type Type Must Be Trivially Copyable Type Not Allowed Here Type Not Arithmetic or Unscoped enum or Pointer Type Not Arithmetic or enum or Pointer Type Not Pointer Type Not Satisfied Type Not Scalar Type Qualifier Ignored Type Qualifier Ignored on Constructor Type Qualifier Not Allowed Type Qualifier on Lambda Type Qualifier on void Return Type Type Qualifiers Ignored on Reference Type Specifier Not Allowed Type With Named Address Space Not Allowed Type With No Linkage in Function Type With No Linkage in Template Argument Type With No Linkage in Variable With Linkage Types Must Have Same Size Typographically Ambiguous Identifiers UPC Requires ANSI C Dialect UPC Shared void Comparison UTF-16 Character Literal Too Long UTF-8 Character Literal Too Long UTF-8 Literal No U-literal Unable to Get Mapped Memory Unattached Attribute Unavailable Entity Unbalanced Attribute Argument Unbalanced Parenthesis Unbounded constexpr Constructor Initialization Priority Recursion Uncallable Elided Copy Constructor Unchecked Parameter Dereference Unclosed String Unclosed __VA_OPT__ Unconvertible Constant Expression Undeclared Parameter Undefined Declaration using Local Type Undefined Declaration using No Linkage Type Undefined IFC Partition Undefined Identifier Undefined Macro in #if Undefined static Function Treated as extern Unexpected Designator Unexpected End of Default Argument Unexpected Template Argument List Unexpected Type for size_t Unfinished Base Class Unhandled IFC Construct Unhandled Swizzle Operand Unicode Name Not Found Unimplemented Keyword Uninitialized Base Class With const Member Uninitialized Field With const Member Uninitialized Variable in constexpr Function Union Type Universal Character Name Names Basic Character Universal Character Name Names Invalid Code Point Universal Character Name Names Surrogate Code Point Unknown IFC Partition Unknown IFC Partition Conversion Unknown Parent Named Address Space Unnamed CLI Managed Class Type Unnamed Class Virtual Function Definition Missing Unnamed Field Unnamed Module Map Unnamed Object With Uninitialized Field Unnamed Require Expression Parameter Unnamed Scoped enum Unnamed Type in Template Argument Unneeded Implicitly Generated Operations Unqualified Function With Qualified Object Unqualified Named Function With Qualified Object Unqualified __super Unrecognized #pragma Unrecognized Attribute Unrecognized Calling Convention Unrecognized Character Escape Unrecognized Format Function Type Unrecognized GCC #pragma Unrecognized GCC Visibility #pragma Unrecognized Microsoft Attribute Unrecognized Microsoft Comment #pragma Type Unrecognized STDC #pragma Unrecognized Target Attribute Unrecognized UPC #pragma Unrecognized Unicode Source Kind Unrecognized Visibility Unreferenced Function Parameter Unrestricted Unions in Microsoft Mode Unscoped Enumeration Unsequenced Use of Variable Unsigned Compare With Negative Unsigned Compare With Zero Unsigned Fixed Point Negation Unsigned enum Bit Field With Signed Enumerator Unspecified Array Size with Designator Initialization Unsupported Header Unit Feature Unsupported Type for Bit Cast Unterminated Delimited Escape Unterminated Escape Sequence Unterminated Unicode Name Unusable Pack Unused Dereference of Reference Class Unused Label Unused Macro Unused Parameter Unused Tag Unused Type Unused Variable Use of #define Use of #elif Use of #elifdef Use of #elifndef Use of #else Use of #endif Use of #error Use of #if Use of #ifdef Use of #ifndef Use of #import Use of #include Use of #include_next Use of #line Use of #pragma Use of #undef Use of #using Use of #warning Use of <cctype> Function Use of <cwctype> Function Use of <fenv.h> Exception Handling Function Use of <setjmp.h> Use of <signal.h> Use of <stdio.h> Input/Output Use of <stdio.h> Input/Output Macro Use of <stdlib.h> Allocator/Deallocator Use of <stdlib.h> Allocator/Deallocator Macro Use of <tgmath.h> Use of <time.h> Time/Date Function Use of <wchar.h> Input/Output Use of <wchar.h> Input/Output Macro Use of AddAccessAllowedAce Use of AddAccessDeniedAce Use of AfxLoadLibrary Use of AfxParseURL Use of Alignas Use of Alignof Use of Array Type Use of Built-in Unary + Operator Use of C Atomic Use of C Generic Use of CoLoadLibrary Use of Comma Operator Use of Generic Class With Pending Constraint Use of L_tmpnam_s Use of NULL Use of Noreturn Use of TMP_MAX_S Use of Thread Local Use of Undefined Function With Deduced Return Type Use of abort Use of abort_handler_s Use of asctime_s Use of atof Use of atoi Use of atol Use of atoll Use of bsearch Use of bsearch_s Use of catch Use of constraint_handler_t Use of ctime_s Use of delete Use of drem Use of exit Use of fopen_s Use of fprintf_s Use of freopen_s Use of fscanf_s Use of fwprintf_s Use of fwscanf_s Use of getenv Use of getenv_s Use of gets Use of gets_s Use of gmtime_s Use of ignore_handler_s Use of localtime_s Use of longjmp Use of mbsrtowcs_s Use of mbstowcs_s Use of memcpy_s Use of memmove_s Use of memset_s Use of new Use of offsetof Use of printf_s Use of putenv Use of qsort Use of qsort_s Use of scanf_s Use of set_constraint_handler_s Use of setjmp Use of snprintf_s Use of snwprintf_s Use of sprintf_s Use of sscanf_s Use of std::bind Use of std::vector<bool> Use of strcat_s Use of strcpy_s Use of strerror_s Use of strerrorlen_s Use of strncat_s Use of strncpy_s Use of strnlen_s Use of strtok_s Use of swprintf_s Use of swscanf_s Use of system Use of throw Use of tmpfile_s Use of tmpnam_s Use of vfprintf_s Use of vfscanf_s Use of vfwprintf_s Use of vfwscanf_s Use of vprintf_s Use of vscanf_s Use of vsnprintf_s Use of vsnwprintf_s Use of vsprintf_s Use of vsscanf_s Use of vswprintf_s Use of vswscanf_s Use of vwprintf_s Use of vwscanf_s Use of wcrtomb_s Use of wcscat_s Use of wcscpy_s Use of wcsncat_s Use of wcsncpy_s Use of wcsnlen_s Use of wcsrtombs_s Use of wcstok_s Use of wcstombs_s Use of wctomb_s Use of wmemcpy_s Use of wmemmove_s Use of wprintf_s Use of wscanf_s Used Before Set Useless Declaration Useless Placement delete Useless Type Qualifier on Return Type Useless Type Qualifiers Useless Type Qualifiers in Type Name Useless using Declaration User-defined Literal Cannot Be Class Member User-defined Literal Operator User-defined String Suffix Mismatch Using Declaration in Header File Using Directive Using Directive in Header File VLA Is Nonstandard VLA Is Not auto VLA Not Allowed VLA Size Ignored VLA Type in Template Argument VLA With Unspecified Bound Not Allowed VLA in Return Type VLA in Statement Expression Vacuous Destructor Not Called Value Class Not Satisfied Value Initialization Priority of Function Value Initialization Priority of Incomplete Value Initialization Priority of Reference Value Initialization Priority of Sizeless Type Value Returned in Constructor Value Returned in void Function Value of #pragma pack(show) Vararg __clrcall Vararg __thiscall Variable Align Attribute Not on Definition Variable Could Be const Variable Hides Entity Variable Not Constant Addressed Variable Not Constant Valued Variable Retained Incomplete Type Variable Template Function Type Variable Templates Requires C++14 Variable Used as Destructor Variable Used as Finalizer Variable With Interface Type Variable With Uninitialized Field Variable With Uninitialized Member Variable With Virtual Bases in constexpr Function Variably Modified Type Not Allowed Variably Modified Type Not Allowed Here Variadic Macro Variadic Templates Requires C++ Vector Element Type Mismatch Vector Length Too Large Vector Operation Requires Integer Vector Vector Size Must Be Multiple of Element Size Vector Size Must Be Power of Two Vector Size Too Large Vector Template Parameter Vector Type Required Vector Types Differ in Length Vectors Must Have Same Size Virtual Base Class Virtual Base Class not In Diamond Virtual Base for Managed Class Virtual Function Cannot Have Deduced Return Type Virtual Function Declaration Hidden Virtual Function Missing virtual/override/final Virtual Function Never Defined Virtual With Explicit this Virtual and Non-Virtual Base Class Virtual inline Never Defined Virtual static Event Virtual static Event Accessor Virtual static Not Allowed Virtual static Property Virtual static Property Accessor Visibility Specifier Requires Definition Visibility Specifier on Nested Type Warning Directive Warnings Not Treated As Errors White Space Inside Splice White Space Required After Macro Name Wide Deprecation String Wide String Invalid in asm Wide String Not Allowed Wrong Entity for Attribute Wrong Entity for alignas Wrong Number of Arguments Yield Outside of Function Yield in catch Zero Length Array Is GNU Extension Zero Length Bit Field Must Be Unnamed Zero Length String _Alignas Deprecated _Alignof Deprecated _Atomic Array or Function Type _Atomic Bit Field _Atomic Specifier With Qualified Type _Bool Deprecated _Noreturn Deprecated _Static_assert Deprecated _Thread_local Deprecated __VA_ARGS__ Not Allowed __VA_OPT__ Not Allowed __auto_type Brace Initialization Not Allowed __auto_type With Secondary Declarator __auto_type Without Initializer __based Not Allowed Here __based Not Followed by Star __based Variable Cannot Be Local __based Variable Must Be Pointer __clrcall Requires C++/CLI __declspec(align(...)) Reduction Ignored __declspec(property) Not Allowed __event __interface Cannot Have Definition __event __interface Must Be Previously Defined __has_cpp_attribute Not in #if __has_include Not in if __has_include_next in Primary Source File __if_exists Not Allowed __if_exists Not Closed __implements Must Precede Virtual Functions __implements Requires Interface __is_signed No Longer a Keyword __leave Must Be in __try __real and __imag Require Complex Argument __real/__imag Applied to Real Value __restrict Is Nonstandard __super After Scope __super Not in Class __thiscall Requires Non-static Member __unaligned Qualifier Dropped __uuidof Requires uuid Class Type abi_tag Ignored abi_tag Ignored in C Mode abi_tag Ignored on Specialization abi_tag Redefinition abstract Requires virtual abstract or sealed on union alignof Function Type alignof Incomplete Array alignof Incomplete Type alignof With Expression Argument always_inline Requires inline always_inline Suppressed asm Declaration Not Allowed asm Function Must Be Prototyped asm Input Must Not Have Output Modifier asm Name After Definition asm Name Conflict asm Name Is GNU Extension asm Name in Routine Definition asm Name in typedef asm Name on auto Variable asm Not Allowed asm Operand Specification Is GNU Extension asm Output Must Have Output Modifier assume Expression Discarded assume Statement Applies to Null Statements auto Brace Initialization Not Allowed auto Cannot Be Disabled auto Cast Requires C++23 auto Direct List Initialization Priority Requires Singleton auto Ignored auto Not Allowed Here auto Type Nonstandard auto Type Requires Initializer auto Type in Array Type auto Type in Function Type auto Used Two Ways auto Variable in Own Initializer auto new With Braced Initialization Priority availability Attribute Ignored begin/end Type Mismatch in Range-based for bool Type Not Allowed break Cannot Be in finally Block break Must Be in Loop or switch carries_dependency Ignored carries_dependency Not on First Declaration case Label Conflict case Label Must Be in switch cc Clobber Ignored cleanup Attribute in constexpr Function co_await Not Allowed Outside Function Scope co_await Not Allowed in Static Initializer co_await Not Allowed in catch Clause co_await Operand Not a Class co_await in Unevaluated Operand co_await on Nonrange Based for coclass Base Requirements Not Met concept Argument List Substitution Failed concept Failed const Function Anachronism const Ignored const Member Suppresses Copy Assignment Declaration const Variable in C Constant Expression const volatile Reference Initializer Anachronism const volatile Reference Initializer From Rvalue consteval Call Nonconstant consteval Constructor With Virtual Base consteval Destructor consteval Explicit Instantiation consteval Overrides Non-consteval consteval Variable consteval Virtual Combination consteval main consteval new or delete Operator constexpr Access One Past Array End constexpr Access Past Object constexpr Access to Expired Storage constexpr Access to Runtime Storage constexpr Address Unknown constexpr Allocation Mismatch constexpr Allocation Position constexpr Allocation Too Large constexpr Allocation Too Small constexpr Bad Deallocation constexpr Bad Deallocation Size constexpr Bad Deallocation Type constexpr Bad Derived Class Cast constexpr Bad Mantissa String constexpr Call Not Interpretable constexpr Call to Non-constexpr Function constexpr Called From constexpr Called From Routine constexpr Cannot Make Zero Length Array constexpr Class Specific new constexpr Comparison Calls Non-constexpr Function constexpr Constructor Does Not Initialize Base constexpr Constructor Initializes No Variant Field constexpr Constructor With Destructor constexpr Constructor With Function try Block constexpr Constructor With Virtual Base constexpr Dependent Array Size constexpr Destructor constexpr Equality Past the End Address constexpr Expiring Temporary constexpr Explicit Destructor Call constexpr Explicit Instantiation constexpr Expression Cannot Be Interpreted constexpr Flexible Array Initializer constexpr Float Error constexpr Floating Point Conversion Failed constexpr Floating Point Error constexpr Floating Point Values Not Comparable constexpr Function Undefined constexpr Function With Function try Block constexpr Ignored on Microsoft Non-static Member constexpr Implied Source Nonconstant constexpr Incomplete Type constexpr Integer Overflow constexpr Interpreter Address constexpr Invalid Constant Kind constexpr Invalid Intrinsic Signature constexpr Invalid Null Pointer Operation constexpr Invalid Pointer Difference constexpr Invalid Pointer to Member Access constexpr Invalid Type Conversion constexpr Invalid dynamic_cast constexpr Lambdas Not Enabled constexpr Leftover Allocations constexpr Length Too Long for make_constexpr_array constexpr Local static constexpr Missing Initializer for Field constexpr Missing Return Value constexpr Modifying const Storage constexpr Multiple union Initializers constexpr Negative Shift constexpr No Active union Field constexpr No Current Parameters constexpr Nonarray Pointer Arithmetic constexpr Nonarray Subscript constexpr Nonvirtual Subobject delete constexpr Not const constexpr Null Callee constexpr Null Dereference constexpr Null Pointer to Member Data constexpr Object With Virtual Base constexpr Out of Bounds Array Access constexpr Placement new constexpr Pointer Ahead of Array constexpr Pointers Not Comparable constexpr Reflection Not of Constant constexpr Return Not Constant constexpr Shift Excess constexpr Shift Negative Value constexpr Statement Cannot Be Interpreted constexpr String Not Null Terminated constexpr Too Many Nested Anonymous Types constexpr Type Invalid constexpr Type Too Large constexpr VLA constexpr Vacuous Destructor Call constexpr Variable Declaration Must Be Definition constexpr Variable Must Have Literal Type constexpr Virtual Base constexpr Virtual Combination constexpr and consteval Specifiers constexpr goto constexpr main constexpr memcpy Distinct Types constexpr memcpy Nontrivial Type constexpr memcpy Operand Not Object constexpr memcpy Overflow constexpr memcpy Overlap constexpr memcpy Partial Object constexpr mutable Field Load constexpr reinterpret_cast constexpr static Data Member Without Initializer constexpr union Field Inactive constexpr volatile Fetch constexpr weak Address constinit Variable Has Dynamic Initializer constinit Variable Storage continue Cannot Be in finally Block continue Must Be in Loop decltype Is Not Base Class decltype(auto) Cannot Be Qualified decltype(auto) Not Allowed Here decltype(auto) Return Must Be Standalone decltype(auto) Type Requires Initializer decltype-qualified Declared Name defined Always False delete Count Anachronism delete of Array Type delete of Array Type Nonstandard delete of Function Pointer delete of Incomplete Class dep_name Requires Parse Nonclass Templates deprecated Attribute dllimport Defined double for long double dynamic_cast Operand Must Be Polymorphic dynamic_cast Without RTTI dynamic_cast to Value Generic enum Attribute Ignored enum Base Type Must Be Integral enum Base Type Too Limited enum Bit Field Too Small enum Not Allowed enum Type Not Allowed enum Type Replacement enum Value Out of Integer Range enum const_cast enum in Managed Class Missing Definition explicit Constructor in Copy List Initialization Priority explicit Deduction Guide in Copy List Initialization Priority explicit Not Allowed export After Definition export Not Allowed export Not at namespace Scope export Template Requires Distinct Template Signatures export Template Requires No implicit_include export on Instantiation ext_vector_type Invalid Size ext_vector_type Not in typedef ext_vector_type Requires Integral Floating Type ext_vector_type Requires bool Integral Floating Type extern C Literal Operator extern Template Follows Instantiation extern inline Never Defined fallthrough Applies to Null Statement fallthrough Not in switch final Base Class final Managed Class for each GetEnumerator Return Type Invalid for each Incompatible Type for each Invalid Return Type for Move Next for each Missing Field for each Missing Function for each No Matching Overload for each Undefined Identifier for each static Function for-init Hidden Declaration for-init Hides Declaration forScope Stack Empty format Routine Not Varargs friend Attribute Requires Definition friend Cannot Add Default Arguments friend Class Template Default Argument Not Allowed friend Is Nonreal Template friend Partial Specialization friend Qualification Ignored friend Specifier Ignored friend Template in Local Class friend With Definition Argument Must Be Definition friend With Definition Argument Must Be Only Declaration gcnew Bad Type Used With Array Initialization Priority gcnew Used With Placement Syntax gcnew Used With auto Syntax gcnew and Abstract gcnew and No Constructor gcnew and No gcnew gcnew of Native Array get Property Function Missing gnu_inline Requires inline hiding Attribute Required hiding Attribute on Nonhiding Member hiding Attribute on Unhidden Member if consteval Nonstandard if consteval Requires Braced Dependent Statement if consteval in Non-constexpr Function if constexpr Requires C++17 ifunc Cannot Be Alias ifunc Cannot Be weak implementation_key Outside Mapping Region implicit_extern_c_type_conversion Only in C++ implicit_include Incompatible With Multiple Translation Units implicit_noexcept Requires noexcept Support import Name Not Allowed initializer_list Not Included initonly Requires Managed Class initonly const Has No Effect initonly static Data Member Not Initialized initonly volatile Not Allowed inline Function Cannot Be Instantiated inline GNU noinline Conflict inline Never Defined inline Non-static Data Member inline Not Allowed inline Qualifier Ignored inline Variables Nonstandard inline and Nonfunction inline main inline new or delete Operator inline on Alias inline on Nested namespace internal_linkage Not on Prior Declaration literal_representation Fixed Point main Coroutine main First Parameter Not Integer main Second Parameter Wrong Type main Wrong Number Parameters microsoft_version Insufficient for C++/CLI microsoft_version Insufficient for C++/CX module Directive in Macro module Directive in if module Name Not Allowed mutable Not Allowed mutable Qualifier on Explicit this Lambda mutable in Embedded C++ namespace Alias Definition Not Allowed namespace CLI Cannot Be Extended namespace Default Cannot Be Extended namespace Definition Not Allowed namespace Name Not Allowed namespace Not Allowed namespace Qualified Name Required new Array Size Must Be Nonnegative new Cast in Embedded C++ new Requires Matching Base Member new Used on Handle or Tracking Reference Type new Used on Managed Class Type new Used on Unsuitable Value Type new of CLI Interface Class new of initializer_list new or override Required new or virtual Required nodiscard Constructor nodiscard Does Not Apply nodiscard Object Type nodiscard Return Type nodiscard Routine nonnull Parameter Number Too Large nonnull on Nonpointer nonstd_gnu_keywords Requires GNU Mode noreturn Function Does Return noreturn With Return Type nullptr Conversion to bool offsetof Bit Field offsetof Nonfield offsetof Reference Field offsetof Virtual Base Member one_instantiation_per_object Incompatible With Multiple Inputs operator-> Loop operator->* in Managed Class overload Anachronism overloadable Attribute Requires Prototype override Requires virtual override and final Requires C++11 override for Interface Member override in final Class partial Class Incorrect Type or Location pass_object_size Not in Function Declaration pin_ptr Parameter Not Allowed pin_ptr Return Type Not Allowed printf Argument Mismatch property Attribute in Managed Class put Property Function Missing register Clobbered Twice register Keyword Deprecated register Keyword Disallowed register Mapped Variable Cannot Have Initializer register Mapped Variable Must Be POD register Name on Non-register register Storage Class Conflict register Too Small register Used Twice register Used and Clobbered register in Address Space register in Use reinterpret_cast of Handle report_gnu_extensions Requires GNU Mode restrict Not Allowed restrict Pointer to Function restrict Qualifier Dropped restrict Qualifier Ignored return in Coroutine sealed Requires virtual sentinel Attribute Requires Ellipsis sentinel Must Be Ellipsis Argument short_enums Requires GCC Mode shufflevector Index Out of Range sizeof Bit Field sizeof Function sizeof Operand Not Parameter Pack sizeof Pack in Nonvariadic Context sizeof Reference or Interface Class start_map_region Ignored static Accessor in Non-static Property or Event static Constructor Member Template static Constructor With Named Override static Constructor With Parameters static Conversion Function Must Have One Parameter static Data Member Not Allowed static Default Indexed Property static Lambda Nonstandard static Lambda With Capture static Literal Field static Member Operator Not Allowed static Non-static With Same Parameter Types static Not Allowed static Storage Variable With Handle or Tracking Reference Type static Storage Variable With Reference Class Type static Variable in inline Function static With Explicit this static extern Template std::float128_t Not Supported std::initializer_list Has Destructor std::meta::infovec Not Initialized std::meta::substitute Bad Argument Reflection std::meta::substitute Failed std::source_location Column Bounds std::source_location Line Bounds struct Not Allowed struct Too Large struct __declspec Ignored in C Mode switch Selector Expression Is Constant switch With Non-enum Expression target on Special Function template Not Allowed template Not in template this Not Constant this Used Incorrectly this in Lambda typedef Cannot Be Parameter Name typedef Modification Is Nonstandard typedef Not Allowed typedef in Elaborated Type typeid Needs <typeinfo> typeid of Incomplete Type typeid of Managed Type typename Needed typename Not in Template typeof Is GNU Extension unavailable Attribute union Already Initialized union Base union Cannot Be Transparent union Cannot Be Transparent Symbol union Non-union Mismatch union constexpr Constructor Initializes No Field using Attribute Nonstandard using Declaration Conflicts With Previous Declaration using Declaration in Embedded C++ using Not at File Scope using Out of Scope Declaration using PCH using enum Conflicts using enum Redeclaration using or Access Declaration in Managed Class va_arg Would Have Been Promoted va_start Requires Ellipsis Function vector_size Attribute Requires Integral Floating or enum Type vector_size Attribute on Complex Type vector_size Attribute on enum Type virtual Function Template virtual Has No Effect virtual Ignored virtual Not Allowed virtual Required for Base Override virtual Required for Interface Implementation virtual in final Class void Named register void Parameter Not Allowed void Property Index Type void Template Parameter void Template Variable void throw volatile Assignment Deprecated volatile Function Parameter Deprecated volatile Increment/Decrement Deprecated volatile Return Type Deprecated volatile Structured Binding Deprecated volatile Type Not Allowed volatile asm Is GNU Extension volatile operator= Deprecated vtbl Option Requires C++ warn_unused_result With void Return wchar_t Option Requires C++	Abort Statements (Ada) Binary Case Statements (Ada) Case Condition Predetermined (Ada) Exception Always Raised (Ada) Function With Side Effects (Ada) Potential Unbounded Loop (Ada) Side Effects in Logical Operand: Function (Ada) Uninitialized Memory Location (Ada) Write Without Open (Ada) abstract type declarations (Ada) access to local objects (Ada) actual parameters (Ada) ada 2022 in ghost code (Ada) ada compatibility (Ada) ada05 formal packages (Ada) address attribute for non volatile objects (Ada) address clause overlay (Ada) address specifications for initialized objects (Ada) address specifications for local objects (Ada) aliasing check (Ada) all checks (Ada) annotated comments (Ada) anonymous access (Ada) anonymous allocators (Ada) anonymous arrays (Ada) anonymous subtypes (Ada) array attribute index (Ada) assertion failure (Ada) at representation clauses (Ada) attribute casing (Ada) bad fixed value (Ada) biased representation (Ada) bit records without layout definition (Ada) blank at end of line (Ada) blocks (Ada) boolean negations (Ada) boolean relational operators (Ada) calls in exception handlers (Ada) calls outside elaboration (Ada) cleartext storage (Ada) comment one space (Ada) comment two spaces (Ada) compiler error (Ada) complex inlined subprograms (Ada) components out of order (Ada) components without representation (Ada) concurrent interfaces (Ada) conditional expressions (Ada) conditional raise (Ada) constant conditional (Ada) constant overlays (Ada) constant variable (Ada) constructors (Ada) controlled type declarations (Ada) dangling dereference (Ada) declaration casing (Ada) declarations in blocks (Ada) deep inheritance hierarchies (Ada) deep library hierarchy (Ada) deeply nested generics (Ada) deeply nested inlining (Ada) deeply nested instantiations (Ada) default GNAT warnings (Ada) default parameters (Ada) default style checks (Ada) default values for record components (Ada) deriving from predefined type (Ada) direct calls to primitives (Ada) direct equalities (Ada) discriminant check (Ada) discriminated records (Ada) dos line terminator (Ada) downward view conversions (Ada) duplicate branches (Ada) elaboration problems (Ada) end exit label (Ada) end of line comments (Ada) enumeration ranges in case statements (Ada) enumeration representation clauses (Ada) exception propagation from callbacks (Ada) exception propagation from export (Ada) exception propagation from tasks (Ada) exceptions as control flow (Ada) exit statements with no loop name (Ada) exits from conditional loops (Ada) expanded loop exit names (Ada) explicit full discrete ranges (Ada) explicit inlining (Ada) exportimport mismatch (Ada) expression functions (Ada) extra conditional parentheses (Ada) extra operator parentheses (Ada) final package (Ada) first controlling parameter (Ada) fixed equality checks (Ada) float equality checks (Ada) floating point underflow (Ada) forbidden aspects (Ada) forbidden attributes (Ada) forbidden pragmas (Ada) form feed or vertical tab (Ada) function out parameters (Ada) function style procedures (Ada) generic in out objects (Ada) generics in subprograms (Ada) global variables (Ada) gnat style (Ada) goto statements (Ada) headers (Ada) hiding declarations (Ada) horizontal tab (Ada) identifier casing (Ada) identifier prefixes (Ada) identifier reference casing (Ada) identifier suffixes (Ada) if then layout (Ada) ignored equality operator (Ada) implementation unit (Ada) implicit dereference (Ada) implicit in mode parameters (Ada) implicit small for fixed point types (Ada) implicitly limited types (Ada) improper input validation (Ada) improper returns (Ada) improperly located instantiations (Ada) incomplete representation specifications (Ada) indentation (Ada) ineffective inline (Ada) ineffective predicate tests (Ada) ineffective warnings off (Ada) information leak (Ada) integer types as enum (Ada) keyword casing (Ada) late dispatching primitives (Ada) library level subprograms (Ada) line length (Ada) line length 80 (Ada) local instantiations (Ada) local packages (Ada) local use clauses (Ada) low bound assumption (Ada) lowercase keywords (Ada) max identifier length (Ada) max nest level (Ada) maximum expression complexity (Ada) maximum lines (Ada) maximum out parameters (Ada) maximum parameters (Ada) maximum subprogram lines (Ada) membership for validity (Ada) membership tests (Ada) metrics cyclomatic complexity (Ada) metrics essential complexity (Ada) metrics lsloc (Ada) min identifier length (Ada) mismatched protected access (Ada) misnamed controlling parameters (Ada) misplaced representation items (Ada) missing parenthesis (Ada) mode in (Ada) multiple entries in protected definitions (Ada) name clashes (Ada) negative operand of exponentiation (Ada) nested paths (Ada) nested subprograms (Ada) no closing names (Ada) no dependence (Ada) no explicit real range (Ada) no inherited classwide pre (Ada) no others in exception handlers (Ada) no scalar storage order specified (Ada) non component in barriers (Ada) non constant overlays (Ada) non qualified aggregates (Ada) non short circuit operators (Ada) non spark attributes (Ada) non tagged derived types (Ada) non visible exceptions (Ada) nonlocal exception (Ada) nonoverlay address specifications (Ada) not imported overlays (Ada) null paths (Ada) number declarations (Ada) numeric format (Ada) numeric indexing (Ada) numeric literals (Ada) object declarations out of order (Ada) object renaming function (Ada) objects of anonymous types (Ada) obsolescent feature (Ada) one construct per line (Ada) one tagged type per package (Ada) operator renamings (Ada) others in aggregates (Ada) others in case statements (Ada) others in exception handlers (Ada) outbound protected assignments (Ada) outer loop exits (Ada) outside references from subprograms (Ada) overlapping actuals (Ada) overloaded operators (Ada) overly nested control structures (Ada) overly nested scopes (Ada) overridden size clause (Ada) overriding indicators (Ada) parameters aliasing (Ada) parameters out of order (Ada) pedantic checks (Ada) pos on enumeration types (Ada) positional actuals for defaulted generic parameters (Ada) positional actuals for defaulted parameters (Ada) positional components (Ada) positional generic parameters (Ada) positional parameters (Ada) postcondition (Ada) potential parameters aliasing (Ada) pragma casing (Ada) precondition (Ada) predefined numeric types (Ada) predicate testing (Ada) printable ascii (Ada) profile discrepancies (Ada) quantified expressions (Ada) questionable layout (Ada) raising external exceptions (Ada) raising predefined exceptions (Ada) read without open (Ada) record holes (Ada) recursive subprograms (Ada) redundant boolean expressions (Ada) redundant construct (Ada) redundant null statements (Ada) reference manual layout (Ada) relative delay statements (Ada) renamings (Ada) representation specifications (Ada) restrictions (Ada) same instantiations (Ada) same logic (Ada) same operands (Ada) same tests (Ada) separate lines after then or else (Ada) separate numeric error handlers (Ada) separates (Ada) server side request forgery (Ada) side effect parameters (Ada) silent exception handlers (Ada) simple loop statements (Ada) single value enumeration types (Ada) size attribute for types (Ada) sizealignment mismatch (Ada) slices (Ada) spark procedures without globals (Ada) specific parent type invariant (Ada) specific pre post (Ada) specific type invariants (Ada) standard identifiers casing (Ada) standard redefinition (Ada) style checks (Ada) subp always fails (Ada) subp never returns (Ada) subprogram access (Ada) subprogram bodies in alphabetical order (Ada) subprogram spec presence (Ada) suspicious constant operation (Ada) suspicious contract (Ada) suspicious equalities (Ada) suspicious input (Ada) suspicious modulus value (Ada) suspicious parameter order (Ada) suspicious precondition (Ada) suspicious subprogram access (Ada) suspicious unchecked conversion (Ada) tag check (Ada) taint error (Ada) token separation (Ada) too many dependencies (Ada) too many generic dependencies (Ada) too many parents (Ada) too many primitives (Ada) trivial exception handlers (Ada) unassigned out parameters (Ada) unassigned parameter (Ada) unassigned variable (Ada) unavailable body calls (Ada) unchecked address conversions (Ada) unchecked conversions as actuals (Ada) uncommented begin (Ada) uncommented begin in package bodies (Ada) uncommented end record (Ada) unconditional exits (Ada) unconstrained array returns (Ada) unconstrained arrays (Ada) uninitialized global variables (Ada) uninitialized value passed to call (Ada) universal ranges (Ada) unknown compile time warning (Ada) unnamed blocks and loops (Ada) unnamed exits (Ada) unnecessary blank lines (Ada) unordered enumeration (Ada) unprotected access (Ada) unprotected shared access (Ada) unread parameter (Ada) unrecognized pragma (Ada) unreferenced formal (Ada) unused entity (Ada) unused out parameter assignment (Ada) use array slices (Ada) use case statements (Ada) use clauses (Ada) use for loops (Ada) use for of loops (Ada) use if expressions (Ada) use memberships (Ada) use of and or (Ada) use package clauses (Ada) use ranges (Ada) use record aggregates (Ada) use simple loops (Ada) use while loops (Ada) user precondition (Ada) variable scoping (Ada) visible components (Ada) volatile objects without address clauses (Ada) warnings (Ada) write through global and parameter (Ada)	Naming Style Violation (Java)	Do not name enum values 'Reserved' (C#) Do not prefix enum values with type name (C#) Events should not have 'Before' or 'After' prefix (C#) Identifier contains type name (C#) Identifiers should differ by more than case (C#) Identifiers should have correct prefix (C#) Identifiers should have correct suffix (C#) Identifiers should not contain underscores (C#) Identifiers should not have incorrect suffix (C#) Identifiers should not match keywords (C#) Naming Style Violation (C#) Parameter names should match base declaration (C#) Property names should not match get methods (C#) Type names should not match namespaces (C#) Use PascalCase for named placeholders (C#)

Significance: Go, Kotlin, Python, Rust, JavaScript, and TypeScript warning classes

diagnostic
redundancy
reliability
security
style

Significance	Warning Classes
Significance	Go	Kotlin	Python	Rust	JavaScript	TypeScript
diagnostic			Astroid Error (Pylint) Config Parse Error (Pylint) Fatal (Pylint) Method Check Failed (Pylint) Parse Error (Pylint)
redundancy	"x = Append(y)" Is Equivalent to "x = Y" (Staticcheck) '&x' Gets Simplified to 'x', It Does Not Copy 'x' (Staticcheck) '(net Url.URL).Query' Returns a Copy, Modifying It Doesn't Change the URL (Staticcheck) 'x % 1' Is Always Zero (Staticcheck) A Function Argument Is Overwritten Before Its First Use (Staticcheck) A Value Assigned to a Variable Is Never Read Before Being Overwritten. Forgotten Error Check or Dead Code? (Staticcheck) 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) Binary Operator Has Identical Expressions on Both Sides (Staticcheck) Break Statement With No Effect. Did You Mean to Break Out of an Outer Loop? (Staticcheck) Calling Functions Like 'math.Ceil' on Floats Converted From Integers Doesn't Do Anything Useful (Staticcheck) Certain Bitwise Operations, Such As 'x ^ 0', Do Not Do Anything Useful (Staticcheck) Checking Never-nil Value Against Nil (Staticcheck) Checking for Impossible Return Value From a Builtin Function (Staticcheck) Comparing 'runtime.GOOS' or 'runtime.GOARCH' Against Impossible Value (Staticcheck) Comparing Unsigned Values Against Negative Values Is Pointless (Staticcheck) Comparing a Value Against NaN Even Though No Value Is Equal to NaN (Staticcheck) Comparing the Address of a Variable Against Nil (Staticcheck) Discarding the Return Values of a Function Without Side Effects, Making the Call Pointless (Staticcheck) Field Assignment That Will Never Be Observed. Did You Mean to Use a Pointer Receiver? (Staticcheck) Go Constants Cannot Express Negative Zero (Staticcheck) Impossible Comparison of Interface Value With Untyped Nil (Staticcheck) Ineffective Attempt at Generating Random Number (Staticcheck) Ineffective Attempt at Sorting Slice (Staticcheck) Integer Division of Literals That Results in Zero (Staticcheck) Multiple, Identical Build Constraints in the Same File (Staticcheck) Negating a Boolean Twice ('!!b') Is the Same As Writing 'b'. This Is Either Redundant, or a Typo. (Staticcheck) Omit Redundant Nil Check Around Loop (Staticcheck) Redundant Call to 'net Http.CanonicalHeaderKey' in Method Call on 'net Http.Header' (Staticcheck) Self-assignment of Variables (Staticcheck) The Loop Exits Unconditionally After One Iteration (Staticcheck) The Result of 'append' Will Never Be Observed Anywhere (Staticcheck) The Variable in the Loop Condition Never Changes, Are You Incrementing the Wrong Variable? (Staticcheck) Type Assertion to Current Type (Staticcheck) Unnecessarily Complex Way of Printing Formatted String (Staticcheck) Unnecessary Guard Around Call to "delete" (Staticcheck) Unnecessary Guard Around Map Access (Staticcheck) Unnecessary Use of 'fmt.Sprint' (Staticcheck) Unreachable Case Clause in a Type Switch (Staticcheck) Unused Code (Staticcheck)	Empty Catch Block (detekt) Empty Class Block (detekt) Empty Default Constructor (detekt) Empty Do While Block (detekt) Empty Else Block (detekt) Empty Finally Block (detekt) Empty Function Block (detekt) Empty If Block (detekt) Empty Init Block (detekt) Empty Kt File (detekt) Empty Secondary Constructor (detekt) Empty Try Block (detekt) Empty When Block (detekt) Empty While Block (detekt) Empty for Block (detekt) Redundant Explicit Type (detekt) Redundant Higher Order Map Usage (detekt) Redundant Suspend Modifier (detekt) Redundant Visibility Modifier Rule (detekt) Unnecessary Abstract Class (detekt) Unnecessary Annotation Use Site Target (detekt) Unnecessary Apply (detekt) Unnecessary Backticks (detekt) Unnecessary Braces Around Trailing Lambda (detekt) Unnecessary Filter (detekt) Unnecessary Inheritance (detekt) Unnecessary Inner Class (detekt) Unnecessary Let (detekt) Unnecessary Not Null Check (detekt) Unnecessary Not Null Operator (detekt) Unnecessary Parentheses (detekt) Unnecessary Part of Binary Expression (detekt) Unnecessary Safe Call (detekt) Unnecessary Temporary Instantiation (detekt) Unreachable Catch Block (detekt) Unreachable Code (detekt) Unused Imports (detekt) Unused Parameter (detekt) Unused Private Class (detekt) Unused Private Member (detekt) Unused Private Property (detekt) Unused Unary Operator (detekt) Useless Call on Not Null (detekt) Useless Postfix Expression (detekt)	Assert on String Literal (Pylint) Assert on Tuple (Pylint) Comparison With Callable (Pylint) Comparison With Itself (Pylint) Comparison of Constants (Pylint) Condition Evals to Constant (Pylint) Duplicate Except (Pylint) Duplicate Key (Pylint) Duplicate String Formatting Argument (Pylint) Duplicate Value (Pylint) Expression Not Assigned (Pylint) F String Without Interpolation (Pylint) Format String Without Interpolation (Pylint) Global Variable Not Assigned (Pylint) Kwarg Superseded By Positional Arg (Pylint) Literal Comparison (Pylint) Missing Parentheses for Call in Test (Pylint) Nan Comparison (Pylint) Nested Min Max (Pylint) Pointless Exception Statement (Pylint) Pointless Statement (Pylint) Pointless String Statement (Pylint) Possibly Unused Variable (Pylint) Redeclared Assigned Name (Pylint) Redundant Keyword Arg (Pylint) Redundant U String Prefix (Pylint) Redundant Unittest Assert (Pylint) Reimported (Pylint) Self Assigning Variable (Pylint) Shadowed Import (Pylint) Try Except Raise (Pylint) Unnecessary Comprehension (Pylint) Unnecessary Dict Index Lookup (Pylint) Unnecessary Ellipsis (Pylint) Unnecessary Lambda (Pylint) Unnecessary List Index Lookup (Pylint) Unnecessary Pass (Pylint) Unnecessary Semicolon (Pylint) Unreachable (Pylint) Unused Argument (Pylint) Unused Format String Argument (Pylint) Unused Format String Key (Pylint) Unused Import (Pylint) Unused Private Member (Pylint) Unused Variable (Pylint) Unused Wildcard Import (Pylint) Useless Else on Loop (Pylint) Useless Object Inheritance (Pylint) Useless Option Value (Pylint) Useless Parent Delegation (Pylint) Useless Return (Pylint) Useless Suppression (Pylint) Useless With Lock (Pylint) Using Constant Test (Pylint)	Cloned Ref to Slice Refs (Rust Clippy) Collection Is Never Read (Rust Clippy) Const Is Empty (Rust Clippy) Duplicate Mod (Rust Clippy) Duplicated Attributes (Rust Clippy) Empty Loop (Rust Clippy) Extra Unused Lifetimes (Rust Clippy) Extra Unused Type Parameters (Rust Clippy) If Same Then Else (Rust Clippy) Ifs Same Cond (Rust Clippy) Impossible Comparisons (Rust Clippy) Ineffective Open Options (Rust Clippy) Join Absolute Paths (Rust Clippy) Manual Inspect (Rust Clippy) Map All Any Identity (Rust Clippy) Modulo One (Rust Clippy) Needless As Bytes (Rust Clippy) Needless If (Rust Clippy) Needless Lifetimes (Rust Clippy) Needless Maybe Sized (Rust Clippy) No Effect (Rust Clippy) Only Used in Recursion (Rust Clippy) Partialeq Ne Impl (Rust Clippy) Redundant As Str (Rust Clippy) Redundant Async Block (Rust Clippy) Redundant Clone (Rust Clippy) Redundant Closure Call (Rust Clippy) Redundant Comparisons (Rust Clippy) Redundant Guards (Rust Clippy) Redundant Locals (Rust Clippy) Redundant Pub Crate (Rust Clippy) Redundant Slicing (Rust Clippy) Redundant Test Prefix (Rust Clippy) Redundant at Rest Pattern (Rust Clippy) Repeat Vec With Capacity (Rust Clippy) Self Assignment (Rust Clippy) Swap With Temporary (Rust Clippy) Temporary Assignment (Rust Clippy) Test Attr in Doctest (Rust Clippy) Unnecessary Clippy Cfg (Rust Clippy) Unnecessary Min or Max (Rust Clippy) Unused Peekable (Rust Clippy) Unused Result Ok (Rust Clippy) Unused Rounding (Rust Clippy) Unused Trait Names (Rust Clippy) Useless Asref (Rust Clippy) Useless Attribute (Rust Clippy) Useless Concat (Rust Clippy) Useless Conversion (Rust Clippy) Useless Format (Rust Clippy) Useless Nonzero New Unchecked (Rust Clippy) Useless Transmute (Rust Clippy)	No Dupe Args (ESLint) No Dupe Class Members (ESLint) No Dupe Else If (ESLint) No Dupe Keys (ESLint) No Duplicate Case (ESLint) No Duplicate Imports (ESLint) No Empty (ESLint) No Empty Character Class (ESLint) No Empty Function (ESLint) No Empty Pattern (ESLint) No Empty Static Block (ESLint) No Eq Null (ESLint) No Extra Bind (ESLint) No Extra Boolean Cast (ESLint) No Extra Label (ESLint) No Extra Semi (ESLint) No Self Assign (ESLint) No Self Compare (ESLint) No Unneeded Ternary (ESLint) No Unreachable (ESLint) No Unreachable Loop (ESLint) No Unused Expressions (ESLint) No Unused Labels (ESLint) No Unused Vars (ESLint) No Useless Backreference (ESLint) No Useless Call (ESLint) No Useless Catch (ESLint) No Useless Computed Key (ESLint) No Useless Concat (ESLint) No Useless Constructor (ESLint) No Useless Escape (ESLint) No Useless Rename (ESLint) No Useless Return (ESLint)	No Unused Vars (TS-ESLint) No Useless Constructor (TS-ESLint) No Useless Empty Export (TS-ESLint) No Useless Template Literals (TS-ESLint)
reliability	"for { Select { ..." With an Empty Default Branch Spins (Staticcheck) '(regexp.Regexp).FindAll' Called With 'n == 0', Which Will Always Return Zero Results (Staticcheck) 'Printf' With Dynamic First Argument and No Further Arguments (Staticcheck) 'TestMain' Doesn't Call 'os.Exit', Hiding Test Failures (Staticcheck) 'else' Branch of a Type Assertion Is Probably Not Reading the Right Value (Staticcheck) 'io.Seeker.Seek' Is Being Called With the Whence Constant As the First Argument, but It Should Be the Second (Staticcheck) 'sort.Slice' Can Only Be Used on Slices (Staticcheck) 'strings.Replace' Called With 'n == 0', Which Does Nothing (Staticcheck) 'sync.WaitGroup.Add' Called Inside the Goroutine, Leading to a Race Condition (Staticcheck) A Nil 'context.Context' Is Being Passed to a Function, Consider Using 'context.TODO' Instead (Staticcheck) A String Cutset Contains Duplicate Characters (Staticcheck) Assigning to 'b.N' in Benchmarks Distorts the Results (Staticcheck) Assignment to Nil Map (Staticcheck) Atomic Access to 64-bit Variable Must Be 64-bit Aligned (Staticcheck) Called 'testing.T.FailNow' or 'SkipNow' in a Goroutine, Which Isn't Allowed (Staticcheck) Cannot Marshal Channels or Functions (Staticcheck) Channels Used With 'os Signal.Notify' Should Be Buffered (Staticcheck) Converting a String to a Slice of Runes Before Ranging Over It (Staticcheck) Copy-Paste Error Deferred 'Lock' Right After Locking, Likely Meant to Defer 'Unlock' Instead (Staticcheck) Deferring 'Close' Before Checking for a Possible Error (Staticcheck) Defers in Infinite Loops Will Never Execute (Staticcheck) Defers in Range Loops May Not Run When You Expect Them to (Staticcheck) Deleting a Directory That Shouldn't Be Deleted (Staticcheck) Dubious Bit Shifting of a Fixed Size Integer Value (Staticcheck) Empty Body in an If or Else Branch (Staticcheck) Empty Critical Section, Did You Mean to Defer the Unlock? (Staticcheck) Impossible Type Assertion (Staticcheck) Inappropriate Key in Call to 'context.WithValue' (Staticcheck) Inefficient String Comparison With 'strings.ToLower' or 'strings.ToUpper' (Staticcheck) Infinite Recursive Call (Staticcheck) Invalid Argument in Call to a 'strconv' Function (Staticcheck) Invalid First Argument to 'exec.Command' (Staticcheck) Invalid Format in 'time.Parse' (Staticcheck) Invalid Printf Call (Staticcheck) Invalid Regular Expression (Staticcheck) Invalid Struct Tag (Staticcheck) Invalid Template (Staticcheck) Invalid URL in 'net Url.Parse' (Staticcheck) It Is Not Possible to Use '(time.Timer).Reset''s Return Value Correctly (Staticcheck) Missing an Optimization Opportunity When Indexing Maps By Byte Slices (Staticcheck) Modifying the Buffer in an 'io.Writer' Implementation (Staticcheck) Non-canonical Key in 'http.Header' Map (Staticcheck) Non-pointer Value Passed to 'Unmarshal' or 'Decode' (Staticcheck) Only the First Constant Has an Explicit Type (Staticcheck) Overlapping Byte Slices Passed to an Encoder (Staticcheck) Passing Odd-sized Slice to Function Expecting Even Size (Staticcheck) Possible Nil Pointer Dereference (Staticcheck) Storing Non-pointer Values in 'sync.Pool' Allocates Memory (Staticcheck) Suspiciously Small Untyped Constant in 'time.Sleep' (Staticcheck) The Empty for Loop ("for {}") Spins and Can Block the Scheduler (Staticcheck) The Finalizer References the Finalized Object, Preventing Garbage Collection (Staticcheck) Trapping a Signal That Cannot Be Trapped (Staticcheck) Trying to Marshal a Struct With No Public Fields Nor Custom Marshaling (Staticcheck) Unsupported Argument to Functions in 'encoding Binary' (Staticcheck) Using 'bytes.Equal' to Compare Two 'net.IP' (Staticcheck) Using 'regexp.Match' or Related in a Loop, Should Use 'regexp.Compile' (Staticcheck) 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) Using Io.WriteString to Write '[]byte' (Staticcheck) Using a Deprecated Function, Variable, Constant or Field (Staticcheck) Using a Non-octal 'os.FileMode' That Looks Like It Was Meant to Be in Octal. (Staticcheck) Using an Invalid Host:port Pair With a 'net.Listen'-related Function (Staticcheck) Various Methods in the "strings" Package Expect Valid UTF-8, but Invalid Input Is Provided (Staticcheck)	Array Primitive (detekt) Avoid Referential Equality (detekt) Cast Nullable to Non Nullable Type (detekt) Cast to Nullable Type (detekt) Copy-Paste Error Could Be Sequence (detekt) Deprecation (detekt) Dont Downcast Collection Types (detekt) Double Mutability for Collection (detekt) Else Case Instead of Exhaustive When (detekt) Equals Always Returns True or False (detekt) Equals With Hash Code Exist (detekt) Exception Raised in Unexpected Location (detekt) Exit Outside Main (detekt) Explicit Garbage Collection Call (detekt) For Each on Range (detekt) Global Coroutine Usage (detekt) Has Platform Type (detekt) Ignored Return Value (detekt) Implicit Default Locale (detekt) Implicit Unit Return Type (detekt) Inject Dispatcher (detekt) Instance of Check for Exception (detekt) Invalid Range (detekt) Iterator Has Next Calls Next Method (detekt) Iterator Not Throwing No Such Element Exception (detekt) Lateinit Usage (detekt) Map Get With Not Null Assertion Operator (detekt) Missing Package Declaration (detekt) Not Implemented Declaration (detekt) Null Check on Mutable Property (detekt) Nullable to String Call (detekt) Object Extends Throwable (detekt) Print Stack Trace (detekt) Property Used Before Declaration (detekt) Rethrow Caught Exception (detekt) Return From Finally (detekt) Sleep Instead of Delay (detekt) Spread Operator (detekt) Suspend Fun Swallowed Cancellation (detekt) Suspend Fun With Coroutine Scope Receiver (detekt) Suspend Fun With Flow Return Type (detekt) Swallowed Exception (detekt) Throwing Exception From Finally (detekt) Throwing Exception in Main (detekt) Throwing Exceptions Without Message or Cause (detekt) Throwing New Instance of Same Exception (detekt) Too Generic Exception Caught (detekt) Too Generic Exception Thrown (detekt) Unconditional Jump Statement in Loop (detekt) Unsafe Call on Nullable Type (detekt) Unsafe Cast (detekt) Unused Object (Java) Unused Value: Actual Parameter (Java) Unused Value: Variable (Java) Unused Value: Write to Parameter (Java) Useless Assignment (Java) Useless Assignment to Default (Java) Wrong Equals Type Parameter (detekt)	Abstract Class Instantiated (Pylint) Access Member Before Definition (Pylint) Anomalous Backslash in String (Pylint) Anomalous Unicode Escape in String (Pylint) Arguments Out of Order (Pylint) Assigning Non Slot (Pylint) Assignment From No Return (Pylint) Assignment From None (Pylint) Await Outside Async (Pylint) Bad Chained Comparison (Pylint) Bad Configuration Section (Pylint) Bad Except Order (Pylint) Bad Exception Cause (Pylint) Bad Format Character (Pylint) Bad Format String (Pylint) Bad Format String Key (Pylint) Bad Indentation (Pylint) Bad Open Mode (Pylint) Bad Plugin Value (Pylint) Bad Reversed Sequence (Pylint) Bad Staticmethod Argument (Pylint) Bad Str Strip Call (Pylint) Bad String Format Type (Pylint) Bad Super Call (Pylint) Bad Thread Instantiation (Pylint) Bidirectional Unicode (Pylint) Binary Op Exception (Pylint) Boolean Datetime (Pylint) Catching Non Exception (Pylint) Cell Var From Loop (Pylint) Class Variable Slots Conflict (Pylint) Continue in Finally (Pylint) Copy-Paste Error Dangerous Default Value (Pylint) Dict Iter Missing Items (Pylint) Duplicate Argument Name (Pylint) Duplicate Bases (Pylint) Forgotten Debug Statement (Pylint) Format Needs Mapping (Pylint) Function Redefined (Pylint) Implicit Str Concat (Pylint) Import Error (Pylint) Inconsistent Mro (Pylint) Inherit Non Class (Pylint) Init Is Generator (Pylint) Invalid All Format (Pylint) Invalid All Object (Pylint) Invalid Bool Returned (Pylint) Invalid Bytes Returned (Pylint) Invalid Character Backspace (Pylint) Invalid Character Carriage Return (Pylint) Invalid Character Esc (Pylint) Invalid Character Nul (Pylint) Invalid Character Sub (Pylint) Invalid Character Zero Width Space (Pylint) Invalid Class Object (Pylint) Invalid Enum Extension (Pylint) Invalid Envvar Default (Pylint) Invalid Envvar Value (Pylint) Invalid Field Call (Pylint) Invalid Format Index (Pylint) Invalid Format Returned (Pylint) Invalid Getnewargs Ex Returned (Pylint) Invalid Getnewargs Returned (Pylint) Invalid Hash Returned (Pylint) Invalid Index Returned (Pylint) Invalid Length Hint Returned (Pylint) Invalid Length Returned (Pylint) Invalid Metaclass (Pylint) Invalid Repr Returned (Pylint) Invalid Sequence Index (Pylint) Invalid Slice Index (Pylint) Invalid Slice Step (Pylint) Invalid Slots (Pylint) Invalid Slots Object (Pylint) Invalid Star Assignment Target (Pylint) Invalid Str Returned (Pylint) Invalid Unary Operand Type (Pylint) Invalid Unicode Codec (Pylint) Isinstance Second Argument Not Valid Type (Pylint) Logging Format Interpolation (Pylint) Logging Format Truncated (Pylint) Logging Fstring Interpolation (Pylint) Logging Not Lazy (Pylint) Logging Too Few Args (Pylint) Logging Too Many Args (Pylint) Logging Unsupported Format (Pylint) Lost Exception (Pylint) Method Hidden (Pylint) Misplaced Bare Raise (Pylint) Misplaced Format Function (Pylint) Misplaced Future (Pylint) Missing Format Argument Key (Pylint) Missing Format Attribute (Pylint) Missing Format String Key (Pylint) Missing Kwoa (Pylint) Missing Timeout (Pylint) Mixed Format String (Pylint) Modified Iterating Dict (Pylint) Modified Iterating List (Pylint) Modified Iterating Set (Pylint) No Member (Pylint) No Method Argument (Pylint) No Name in Module (Pylint) No Self Argument (Pylint) No Value for Parameter (Pylint) Non Ascii File Name (Pylint) Non Iterator Returned (Pylint) Non Str Assignment to Dunder Name (Pylint) Nonexistent Operator (Pylint) Nonlocal Without Binding (Pylint) Nonlocal and Global (Pylint) Not Async Context Manager (Pylint) Not Callable (Pylint) Not Context Manager (Pylint) Not a Mapping (Pylint) Not an Iterable (Pylint) Not in Loop (Pylint) Notimplemented Raised (Pylint) Positional Only Arguments Expected (Pylint) Potential Index Error (Pylint) Raise Missing From (Pylint) Raising Bad Type (Pylint) Raising Format Tuple (Pylint) Raising Non Exception (Pylint) Repeated Keyword (Pylint) Return Arg in Generator (Pylint) Return Outside Function (Pylint) Return in Init (Pylint) Shallow Copy Environ (Pylint) Singledispatch Method (Pylint) Singledispatchmethod Function (Pylint) Star Needs Assignment Target (Pylint) Subprocess Popen Preexec Fn (Pylint) Subprocess Run Check (Pylint) Syntax Error (Pylint) Too Few Format Args (Pylint) Too Many Format Args (Pylint) Too Many Function Args (Pylint) Too Many Star Expressions (Pylint) Truncated Format String (Pylint) Unbalanced Dict Unpacking (Pylint) Unbalanced Tuple Unpacking (Pylint) Undefined All Variable (Pylint) Undefined Loop Variable (Pylint) Undefined Variable (Pylint) Unexpected Keyword Arg (Pylint) Unexpected Special Method Signature (Pylint) Unhashable Member (Pylint) Unknown Option Value (Pylint) Unpacking Non Sequence (Pylint) Unrecognized Inline Option (Pylint) Unrecognized Option (Pylint) Unspecified Encoding (Pylint) Unsubscriptable Object (Pylint) Unsupported Assignment Operation (Pylint) Unsupported Binary Operation (Pylint) Unsupported Delete Operation (Pylint) Unsupported Membership Test (Pylint) Used Before Assignment (Pylint) Used Prior Global Declaration (Pylint) Using F String in Unsupported Version (Pylint) Using Final Decorator in Unsupported Version (Pylint) Wrong Exception Operation (Pylint) Yield Inside Async Function (Pylint) Yield Outside Function (Pylint)	Absurd Extreme Comparisons (Rust Clippy) Almost Complete Range (Rust Clippy) Almost Swapped (Rust Clippy) Approx Constant (Rust Clippy) Arc With Non Send Sync (Rust Clippy) As Pointer Underscore (Rust Clippy) Async Yields Async (Rust Clippy) Await Holding Invalid Type (Rust Clippy) Await Holding Lock (Rust Clippy) Await Holding Refcell Ref (Rust Clippy) Bad Bit Mask (Rust Clippy) Blanket Clippy Restriction Lints (Rust Clippy) Cast Abs to Unsigned (Rust Clippy) Cast Enum Constructor (Rust Clippy) Cast Enum Truncation (Rust Clippy) Cast Nan to Int (Rust Clippy) Cast Slice Different Sizes (Rust Clippy) Cast Slice From Raw Parts (Rust Clippy) Coerce Container to Any (Rust Clippy) Confusing Method to Numeric Cast (Rust Clippy) Copy-Paste Error Crate in Macro Def (Rust Clippy) Deprecated Semver (Rust Clippy) Derive Ord Xor Partial Ord (Rust Clippy) Derived Hash With Manual Eq (Rust Clippy) Drop Non Drop (Rust Clippy) Eager Transmute (Rust Clippy) Enum Clike Unportable Variant (Rust Clippy) Eq Op (Rust Clippy) Erasing Op (Rust Clippy) Float Equality Without Abs (Rust Clippy) Forget Non Drop (Rust Clippy) Four Forward Slashes (Rust Clippy) From Raw With Void Ptr (Rust Clippy) If Let Mutex (Rust Clippy) Impl Hash Borrow With Str and Bytes (Rust Clippy) Incompatible Msrv (Rust Clippy) Ineffective Bit Mask (Rust Clippy) Infallible Try From (Rust Clippy) Infinite Iter (Rust Clippy) Inherent to String Shadow Display (Rust Clippy) Inline Fn Without Body (Rust Clippy) Invalid Regex (Rust Clippy) Invisible Characters (Rust Clippy) Iter Next Loop (Rust Clippy) Iter Out of Bounds (Rust Clippy) Iter Skip Zero (Rust Clippy) Iterator Step By Zero (Rust Clippy) Let Underscore Future (Rust Clippy) Let Underscore Lock (Rust Clippy) Lines Filter Map Ok (Rust Clippy) Lint Groups Priority (Rust Clippy) Literal String With Formatting Args (Rust Clippy) Match Str Case Mismatch (Rust Clippy) Mem Replace With Uninit (Rust Clippy) Min Max (Rust Clippy) Misnamed Getters (Rust Clippy) Misrefactored Assign Op (Rust Clippy) Missing Transmute Annotations (Rust Clippy) Mistyped Literal Suffixes (Rust Clippy) Multi Assignments (Rust Clippy) Mut From Ref (Rust Clippy) Mut Range Bound (Rust Clippy) Mutable Key Type (Rust Clippy) Neg Cmp Op on Partial Ord (Rust Clippy) Never Loop (Rust Clippy) No Effect Replace (Rust Clippy) Non Canonical Clone Impl (Rust Clippy) Non Canonical Partial Ord Impl (Rust Clippy) Non Octal Unix Permissions (Rust Clippy) Nonsensical Open Options (Rust Clippy) Not Unsafe Ptr Arg Deref (Rust Clippy) Octal Escapes (Rust Clippy) Option Env Unwrap (Rust Clippy) Out of Bounds Indexing (Rust Clippy) Overly Complex Bool Expr (Rust Clippy) Panicking Overflow Checks (Rust Clippy) Panicking Unwrap (Rust Clippy) Path Ends With Ext (Rust Clippy) Possible Missing Comma (Rust Clippy) Print in Format Impl (Rust Clippy) Rc Clone in Vec Init (Rust Clippy) Read Line Without Trim (Rust Clippy) Recursive Format Impl (Rust Clippy) Repr Packed Without Abi (Rust Clippy) Reversed Empty Ranges (Rust Clippy) Serde Api Misuse (Rust Clippy) Single Range in Vec Init (Rust Clippy) Size of Ref (Rust Clippy) Size of in Element Count (Rust Clippy) Sliced String As Bytes (Rust Clippy) Suspicious Arithmetic Impl (Rust Clippy) Suspicious Assignment Formatting (Rust Clippy) Suspicious Command Arg Space (Rust Clippy) Suspicious Doc Comments (Rust Clippy) Suspicious Else Formatting (Rust Clippy) Suspicious Map (Rust Clippy) Suspicious Op Assign Impl (Rust Clippy) Suspicious Open Options (Rust Clippy) Suspicious Operation Groupings (Rust Clippy) Suspicious Splitn (Rust Clippy) Suspicious Unary Op Formatting (Rust Clippy) Suspicious to Owned (Rust Clippy) Swap Ptr to Ref (Rust Clippy) Trailing Empty Array (Rust Clippy) Transmute Null to Fn (Rust Clippy) Transmuting Null (Rust Clippy) Type Id on Box (Rust Clippy) Unbuffered Bytes (Rust Clippy) Unconditional Recursion (Rust Clippy) Uninhabited References (Rust Clippy) Uninit Assumed Init (Rust Clippy) Uninit Vec (Rust Clippy) Unit Cmp (Rust Clippy) Unit Hash (Rust Clippy) Unit Return Expecting Ord (Rust Clippy) Unsound Collection Transmute (Rust Clippy) Unused Io Amount (Rust Clippy) Vec Resize to Zero (Rust Clippy) While Float (Rust Clippy) While Immutable Condition (Rust Clippy) Wrong Transmute (Rust Clippy) Zero Repeat Side Effects (Rust Clippy) Zombie Processes (Rust Clippy) Zst Offset (Rust Clippy)	Array Callback Return (ESLint) Constructor Super (ESLint) Copy-Paste Error For Direction (ESLint) Getter Return (ESLint) Require Atomic Updates (ESLint) Use Isnan (ESLint) Valid Typeof (ESLint)	Await Thenable (TS-ESLint) Class Literal Property Style (TS-ESLint) Copy-Paste Error Explicit Function Return Type (TS-ESLint) Explicit Member Accessibility (TS-ESLint) Explicit Module Boundary Types (TS-ESLint) Parameter Properties (TS-ESLint) Require Array Sort Compare (TS-ESLint) Restrict Template Expressions (TS-ESLint) Return Await (TS-ESLint) Unbound Method (TS-ESLint)
security		Code Injection (Java) Command Injection (Java) Cryptographic Algorithm with Risky Default Cipher (Java) Cryptographic Algorithm with Weak Cipher (Java) Cryptographic Algorithm with Weak Hash (Java) Deprecated Cryptography Provider (Java) Hardcoded Cryptographic Key (Java) Hardcoded Password (Java) Insecure Key Derivation (Java) Missing Required Cryptographic Step (Java) Possible XML External Entity Reference (Java) Reflection Injection (Java) Risky Cipher Algorithm (Java) Risky Cipher Field (Java) Risky Cryptographic Algorithm (Java) Risky Cryptographic Field (Java) SQL Injection (Java) Tainted @Trusted Value (Java) Tainted Allocation Size (Java) Tainted Bundle (Java) Tainted Control (Java) Tainted Data in Vulnerable Method (Java) Tainted Expression Evaluation (Java) Tainted HTTP Response (Java) Tainted LDAP Attribute (Java) Tainted LDAP Filter (Java) Tainted Log (Java) Tainted Message (Java) Tainted Network Address (Java) Tainted Path (Java) Tainted Regular Expression (Java) Tainted Resource (Java) Tainted Session (Java) Tainted URL (Java) Tainted XAML (Java) Tainted XML (Java) Tainted Xpath (Java) Unsafe hash comparison (Java) Use of Hash without a Salt (Java) Weak Cryptographic Value (Java) Weak Hash Algorithm (Java) Weak Hash Algorithm Field (Java) Weak Initialization Vector Field (Java) Weak Initialization Vector Value (Java)	Eval Used (Pylint) Exec Used (Pylint) Relative Beyond Top Level (Pylint)	Char Indices As Byte Indices (Rust Clippy) Integer Division Remainder Used (Rust Clippy) Inverted Saturating Sub (Rust Clippy) Permissions Set Readonly False (Rust Clippy) Pointer Format (Rust Clippy)	No Eval (ESLint)
style	A Function's Error Value Should Be Its Last Return Value (Staticcheck) A Switch's Default Case Should Be the First or Last Case (Staticcheck) Avoid Zero-width and Control Characters in String Literals (Staticcheck) Don't Use 'fmt.Sprintf("%s", X)' Unnecessarily (Staticcheck) Don't Use Yoda Conditions (Staticcheck) Dot Imports Are Discouraged (Staticcheck) Drop Unnecessary Use of the Blank Identifier (Staticcheck) Elaborate Way of Sleeping (Staticcheck) Importing the Same Package Multiple Times (Staticcheck) Incorrect or Missing Package Comment (Staticcheck) Incorrectly Formatted Error String (Staticcheck) Merge Variable Declaration and Assignment (Staticcheck) Omit Comparison With Boolean Constant (Staticcheck) Omit Default Slice Index (Staticcheck) Omit Redundant Control Flow (Staticcheck) Omit Redundant Nil Check in Type Assertion (Staticcheck) Omit Redundant Nil Check on Slices (Staticcheck) Poorly Chosen Identifier (Staticcheck) Poorly Chosen Name for Error Variable (Staticcheck) Poorly Chosen Name for Variable of Type 'time.Duration' (Staticcheck) Poorly Chosen Receiver Name (Staticcheck) Range Over the String Directly (Staticcheck) Redundant Type in Variable Declaration (Staticcheck) Replace 'time.Now().Sub(x)' With 'time.Since(x)' (Staticcheck) Replace 'x.Sub(time.Now())' With 'time.Until(x)' (Staticcheck) Replace Call to 'bytes.Compare' With 'bytes.Equal' (Staticcheck) Replace Call to 'strings.Index' With 'strings.Contains' (Staticcheck) Replace Manual Trimming With 'strings.TrimPrefix' (Staticcheck) Replace for Loop With Call to Copy (Staticcheck) Should Use Constants for HTTP Error Codes, Not Magic Numbers (Staticcheck) Simplify "make" Call By Omitting Redundant Arguments (Staticcheck) Simplify Error Construction With 'fmt.Errorf' (Staticcheck) Simplify Regular Expression By Using Raw String Literal (Staticcheck) Simplify Returning Boolean Expression (Staticcheck) The Documentation of an Exported Function Should Start With the Function's Name (Staticcheck) The Documentation of an Exported Type Should Start With Type's Name (Staticcheck) The Documentation of an Exported Variable or Constant Should Start With Variable's Name (Staticcheck) Use "copy" for Sliding Elements (Staticcheck) Use "for { ... }" for Infinite Loops (Staticcheck) Use 'bytes.Buffer.String' or 'bytes.Buffer.Bytes' (Staticcheck) Use 'sort.Ints(x)', 'sort.Float64s(x)', and 'sort.Strings(x)' (Staticcheck) Use Consistent Method Receiver Names (Staticcheck) Use Plain Channel Send or Receive Instead of Single-case Select (Staticcheck) Use Result of Type Assertion to Simplify Cases (Staticcheck) Use a Single 'append' to Concatenate Two Slices (Staticcheck) Use a Type Conversion Instead of Manually Copying Struct Fields (Staticcheck)	Absent or Wrong File License (detekt) Also Could Be Apply (detekt) Boolean Property Naming (detekt) Braces on If Statements (detekt) Braces on When Statements (detekt) Can Be Non Nullable (detekt) Cascading Call Wrapping (detekt) Class Naming (detekt) Class Ordering (detekt) Cognitive Complex Method (detekt) Collapsible If Statements (detekt) Comment Over Private Function (detekt) Comment Over Private Property (detekt) Complex Condition (detekt) Complex Interface (detekt) Constructor Parameter Naming (detekt) Cyclomatic Complex Method (detekt) Data Class Contains Functions (detekt) Data Class Should Be Immutable (detekt) Deprecated Block Tag (detekt) Destructuring Declaration With Too Many Entries (detekt) Double Negative Lambda (detekt) End of Sentence Format (detekt) Enum Naming (detekt) Equals Null Call (detekt) Equals on Signature Line (detekt) Explicit Collection Element Access Method (detekt) Explicit It Lambda Parameter (detekt) Expression Body Syntax (detekt) Forbidden Annotation (detekt) Forbidden Class Name (detekt) Forbidden Comment (detekt) Forbidden Import (detekt) Forbidden Method Call (detekt) Forbidden Suppress (detekt) Forbidden Void (detekt) Function Max Length (detekt) Function Min Length (detekt) Function Naming (detekt) Function Only Returning Constant (detekt) Function Parameter Naming (detekt) Invalid Package Declaration (detekt) KDoc References Non Public Property (detekt) Labeled Expression (detekt) Lambda Parameter Naming (detekt) Large Class (detekt) Long Method (detekt) Long Parameter List (detekt) Loop With Too Many Jump Statements (detekt) Magic Number (detekt) Mandatory Braces Loops (detekt) Matching Declaration Name (detekt) Max Chained Calls on Same Line (detekt) Max Line Length (detekt) May Be Const (detekt) Member Name Equals Class Name (detekt) Method Overloading (detekt) Modifier Order (detekt) Multiline Lambda It Parameter (detekt) Multiline Raw String Indentation (detekt) Named Arguments (detekt) Nested Block Depth (detekt) Nested Classes Visibility (detekt) Nested Scope Functions (detekt) New Line at End of File (detekt) No Name Shadowing (detekt) No Tabs (detekt) Non Boolean Property Prefixed With Is (detekt) Nullable Boolean Check (detekt) Object Literal to Lambda (detekt) Object Property Naming (detekt) Optional Abstract Keyword (detekt) Optional Unit (detekt) Outdated Documentation (detekt) Package Naming (detekt) Prefer to Over Pair Syntax (detekt) Protected Member in Final Class (detekt) Replace Safe Call Chain With Run (detekt) Return Count (detekt) Safe Cast (detekt) Serial Version UIDIn Serializable Class (detekt) Spacing Between Package and Imports (detekt) String Literal Duplication (detekt) String Should Be Raw String (detekt) Throws Count (detekt) Too Many Functions (detekt) Top Level Property Naming (detekt) Trailing Whitespace (detekt) Trim Multiline Raw String (detekt) Underscores in Numeric Literals (detekt) Undocumented Public Class (detekt) Undocumented Public Function (detekt) Undocumented Public Property (detekt) Until Instead of Range to (detekt) Use Any or None Instead of Find (detekt) Use Array Literals in Annotations (detekt) Use Check Not Null (detekt) Use Check or Error (detekt) Use Data Class (detekt) Use Empty Counterpart (detekt) Use If Empty or If Blank (detekt) Use If Instead of When (detekt) Use Is Null or Empty (detekt) Use Let (detekt) Use Require (detekt) Use Require Not Null (detekt) Use Sum of Instead of Flat Map Size (detekt) Use or Empty (detekt) Utility Class With Public Constructor (detekt) Var Could Be Val (detekt) Variable Max Length (detekt) Variable Min Length (detekt) Variable Naming (detekt) Wildcard Import (detekt)	Abstract Method (Pylint) Arguments Differ (Pylint) Arguments Renamed (Pylint) Attribute Defined Outside Init (Pylint) Bad Classmethod Argument (Pylint) Bad File Encoding (Pylint) Bad Inline Option (Pylint) Bad Mcs Classmethod Argument (Pylint) Bad Mcs Method Argument (Pylint) Bare Except (Pylint) Broad Exception Caught (Pylint) Broad Exception Raised (Pylint) C Extension No Member (Pylint) Chained Comparison (Pylint) Confusing With Statement (Pylint) Consider Iterating Dictionary (Pylint) Consider Merging Isinstance (Pylint) Consider Swap Variables (Pylint) Consider Using Dict Comprehension (Pylint) Consider Using Dict Items (Pylint) Consider Using Enumerate (Pylint) Consider Using F String (Pylint) Consider Using From Import (Pylint) Consider Using Generator (Pylint) Consider Using Get (Pylint) Consider Using Join (Pylint) Consider Using Max Builtin (Pylint) Consider Using Min Builtin (Pylint) Consider Using Set Comprehension (Pylint) Consider Using Sys Exit (Pylint) Consider Using Ternary (Pylint) Consider Using With (Pylint) Consider Using in (Pylint) Cyclic Import (Pylint) Deprecated Argument (Pylint) Deprecated Class (Pylint) Deprecated Decorator (Pylint) Deprecated Method (Pylint) Deprecated Module (Pylint) Deprecated Pragma (Pylint) Disallowed Name (Pylint) Duplicate Code (Pylint) Empty Docstring (Pylint) File Ignored (Pylint) Fixme (Pylint) Format Combined Specification (Pylint) Global Statement (Pylint) Global Variable Undefined (Pylint) Global at Module Level (Pylint) Implicit Flag Alias (Pylint) Import Outside Toplevel (Pylint) Import Self (Pylint) Inconsistent Quotes (Pylint) Inconsistent Return Statements (Pylint) Invalid Characters in Docstring (Pylint) Invalid Name (Pylint) Invalid Overridden Method (Pylint) Keyword Arg Before Vararg (Pylint) Line Too Long (Pylint) Locally Disabled (Pylint) Method Cache Max Size None (Pylint) Missing Class Docstring (Pylint) Missing Final Newline (Pylint) Missing Function Docstring (Pylint) Missing Module Docstring (Pylint) Mixed Line Endings (Pylint) Multiple Imports (Pylint) Multiple Statements (Pylint) Named Expr Without Context (Pylint) No Classmethod Decorator (Pylint) No Else Break (Pylint) No Else Continue (Pylint) No Else Raise (Pylint) No Else Return (Pylint) No Staticmethod Decorator (Pylint) Non Ascii Module Import (Pylint) Non Ascii Name (Pylint) Non Parent Init Called (Pylint) Overridden Final Method (Pylint) Preferred Module (Pylint) Property With Parameters (Pylint) Protected Access (Pylint) Raw Checker Failed (Pylint) Redefined Argument From Local (Pylint) Redefined Builtin (Pylint) Redefined Outer Name (Pylint) Redefined Slots in Subclass (Pylint) Return in Finally (Pylint) Self Cls Assignment (Pylint) Signature Differs (Pylint) Simplifiable Condition (Pylint) Simplifiable If Expression (Pylint) Simplifiable If Statement (Pylint) Simplify Boolean Expression (Pylint) Single String Used for Slots (Pylint) Singleton Comparison (Pylint) Stop Iteration Return (Pylint) Subclassed Final Class (Pylint) Super Init Not Called (Pylint) Super With Arguments (Pylint) Super Without Brackets (Pylint) Superfluous Parens (Pylint) Suppressed Message (Pylint) Too Few Public Methods (Pylint) Too Many Ancestors (Pylint) Too Many Arguments (Pylint) Too Many Boolean Expressions (Pylint) Too Many Branches (Pylint) Too Many Instance Attributes (Pylint) Too Many Lines (Pylint) Too Many Locals (Pylint) Too Many Nested Blocks (Pylint) Too Many Public Methods (Pylint) Too Many Return Statements (Pylint) Too Many Statements (Pylint) Trailing Comma Tuple (Pylint) Trailing Newlines (Pylint) Trailing Whitespace (Pylint) Typevar Double Variance (Pylint) Typevar Name Incorrect Variance (Pylint) Typevar Name Mismatch (Pylint) Unexpected Line Ending Format (Pylint) Ungrouped Imports (Pylint) Unidiomatic Typecheck (Pylint) Unnecessary Direct Lambda Call (Pylint) Unnecessary Dunder Call (Pylint) Unnecessary Lambda Assignment (Pylint) Unnecessary Negation (Pylint) Use Dict Literal (Pylint) Use Implicit Booleaness Not Comparison (Pylint) Use Implicit Booleaness Not Comparison to String (Pylint) Use Implicit Booleaness Not Comparison to Zero (Pylint) Use Implicit Booleaness Not Len (Pylint) Use List Literal (Pylint) Use Maxsplit Arg (Pylint) Use Sequence for Iteration (Pylint) Use Symbolic Message Instead (Pylint) Use a Generator (Pylint) Useless Import Alias (Pylint) Wildcard Import (Pylint) Wrong Import Order (Pylint) Wrong Import Position (Pylint) Wrong Spelling in Comment (Pylint) Wrong Spelling in Docstring (Pylint)	Absolute Paths (Rust Clippy) Alloc Instead of Core (Rust Clippy) Allow Attributes (Rust Clippy) Allow Attributes Without Reason (Rust Clippy) Arbitrary Source Item Ordering (Rust Clippy) Arithmetic Side Effects (Rust Clippy) As Conversions (Rust Clippy) As Ptr Cast Mut (Rust Clippy) As Underscore (Rust Clippy) Assertions on Constants (Rust Clippy) Assertions on Result States (Rust Clippy) Assign Op Pattern (Rust Clippy) Assign Ops (Rust Clippy) Assigning Clones (Rust Clippy) Big Endian Bytes (Rust Clippy) Bind Instead of Map (Rust Clippy) Blocks in Conditions (Rust Clippy) Bool Assert Comparison (Rust Clippy) Bool Comparison (Rust Clippy) Bool to Int With If (Rust Clippy) Borrow As Ptr (Rust Clippy) Borrow Deref Ref (Rust Clippy) Borrow Interior Mutable Const (Rust Clippy) Borrowed Box (Rust Clippy) Box Collection (Rust Clippy) Box Default (Rust Clippy) Boxed Local (Rust Clippy) Branches Sharing Code (Rust Clippy) Builtin Type Shadow (Rust Clippy) Byte Char Slices (Rust Clippy) Bytes Count to Len (Rust Clippy) Bytes Nth (Rust Clippy) Cargo Common Metadata (Rust Clippy) Case Sensitive File Extension Comparisons (Rust Clippy) Cast Lossless (Rust Clippy) Cast Possible Truncation (Rust Clippy) Cast Possible Wrap (Rust Clippy) Cast Precision Loss (Rust Clippy) Cast Ptr Alignment (Rust Clippy) Cast Sign Loss (Rust Clippy) Cfg Not Test (Rust Clippy) Char Lit As U8 (Rust Clippy) Chars Last Cmp (Rust Clippy) Chars Next Cmp (Rust Clippy) Checked Conversions (Rust Clippy) Clear With Drain (Rust Clippy) Clone on Copy (Rust Clippy) Clone on Ref Ptr (Rust Clippy) Cloned Instead of Copied (Rust Clippy) Cmp Null (Rust Clippy) Cmp Owned (Rust Clippy) Cognitive Complexity (Rust Clippy) Collapsible Else If (Rust Clippy) Collapsible If (Rust Clippy) Collapsible Match (Rust Clippy) Collapsible Str Replace (Rust Clippy) Comparison Chain (Rust Clippy) Comparison to Empty (Rust Clippy) Copy Iterator (Rust Clippy) Create Dir (Rust Clippy) Crosspointer Transmute (Rust Clippy) Dbg Macro (Rust Clippy) Debug Assert With Mut Call (Rust Clippy) Decimal Literal Representation (Rust Clippy) Declare Interior Mutable Const (Rust Clippy) Default Constructed Unit Structs (Rust Clippy) Default Instead of Iter Empty (Rust Clippy) Default Numeric Fallback (Rust Clippy) Default Trait Access (Rust Clippy) Default Union Representation (Rust Clippy) Deprecated Cfg Attr (Rust Clippy) Deprecated Clippy Cfg Attr (Rust Clippy) Deref Addrof (Rust Clippy) Deref By Slicing (Rust Clippy) Derivable Impls (Rust Clippy) Derive Partial Eq Without Eq (Rust Clippy) Disallowed Macros (Rust Clippy) Disallowed Methods (Rust Clippy) Disallowed Names (Rust Clippy) Disallowed Script Idents (Rust Clippy) Disallowed Types (Rust Clippy) Diverging Sub Expression (Rust Clippy) Doc Comment Double Space Linebreaks (Rust Clippy) Doc Include Without Cfg (Rust Clippy) Doc Lazy Continuation (Rust Clippy) Doc Link Code (Rust Clippy) Doc Link With Quotes (Rust Clippy) Doc Markdown (Rust Clippy) Doc Nested Refdefs (Rust Clippy) Doc Overindented List Items (Rust Clippy) Doc Suspicious Footnotes (Rust Clippy) Double Comparisons (Rust Clippy) Double Ended Iterator Last (Rust Clippy) Double Must Use (Rust Clippy) Double Parens (Rust Clippy) Drain Collect (Rust Clippy) Duplicate Underscore Argument (Rust Clippy) Duration Subsec (Rust Clippy) Elidable Lifetime Names (Rust Clippy) Else If Without Else (Rust Clippy) Empty Docs (Rust Clippy) Empty Drop (Rust Clippy) Empty Enum (Rust Clippy) Empty Enum Variants With Brackets (Rust Clippy) Empty Line After Doc Comments (Rust Clippy) Empty Line After Outer Attr (Rust Clippy) Empty Structs With Brackets (Rust Clippy) Enum Glob Use (Rust Clippy) Enum Variant Names (Rust Clippy) Equatable If Let (Rust Clippy) Err Expect (Rust Clippy) Error Impl Error (Rust Clippy) Excessive Nesting (Rust Clippy) Excessive Precision (Rust Clippy) Exhaustive Enums (Rust Clippy) Exhaustive Structs (Rust Clippy) Exit (Rust Clippy) Expect Fun Call (Rust Clippy) Expect Used (Rust Clippy) Expl Impl Clone on Copy (Rust Clippy) Explicit Auto Deref (Rust Clippy) Explicit Counter Loop (Rust Clippy) Explicit Deref Methods (Rust Clippy) Explicit Into Iter Loop (Rust Clippy) Explicit Iter Loop (Rust Clippy) Explicit Write (Rust Clippy) Extend From Slice (Rust Clippy) Extend With Drain (Rust Clippy) Fallible Impl From (Rust Clippy) Field Reassign With Default (Rust Clippy) Field Scoped Visibility Modifiers (Rust Clippy) Filetype Is File (Rust Clippy) Filter Map Bool Then (Rust Clippy) Filter Map Identity (Rust Clippy) Filter Map Next (Rust Clippy) Filter Next (Rust Clippy) Flat Map Identity (Rust Clippy) Flat Map Option (Rust Clippy) Float Arithmetic (Rust Clippy) Float Cmp (Rust Clippy) Float Cmp Const (Rust Clippy) Fn Params Excessive Bools (Rust Clippy) Fn to Numeric Cast (Rust Clippy) Fn to Numeric Cast Any (Rust Clippy) Fn to Numeric Cast With Truncation (Rust Clippy) For Kv Map (Rust Clippy) Format Collect (Rust Clippy) Format Push String (Rust Clippy) Format in Format Args (Rust Clippy) From Iter Instead of Collect (Rust Clippy) From Over Into (Rust Clippy) From Str Radix 10 (Rust Clippy) Future Not Send (Rust Clippy) Get First (Rust Clippy) Get Last With Len (Rust Clippy) Get Unwrap (Rust Clippy) Host Endian Bytes (Rust Clippy) Identity Op (Rust Clippy) If Not Else (Rust Clippy) If Then Some Else None (Rust Clippy) Ignore Without Reason (Rust Clippy) Ignored Unit Patterns (Rust Clippy) Impl Trait in Params (Rust Clippy) Implicit Clone (Rust Clippy) Implicit Hasher (Rust Clippy) Implicit Return (Rust Clippy) Implicit Saturating Add (Rust Clippy) Implicit Saturating Sub (Rust Clippy) Implied Bounds in Impls (Rust Clippy) Imprecise Flops (Rust Clippy) Inconsistent Digit Grouping (Rust Clippy) Inconsistent Struct Constructor (Rust Clippy) Index Refutable Slice (Rust Clippy) Indexing Slicing (Rust Clippy) Inefficient to String (Rust Clippy) Infallible Destructuring Match (Rust Clippy) Infinite Loop (Rust Clippy) Inherent to String (Rust Clippy) Init Numbered Fields (Rust Clippy) Inline Always (Rust Clippy) Inline Asm X86 Att Syntax (Rust Clippy) Inline Asm X86 Intel Syntax (Rust Clippy) Inspect for Each (Rust Clippy) Int Plus One (Rust Clippy) Integer Division (Rust Clippy) Into Iter Without Iter (Rust Clippy) Into Iter on Ref (Rust Clippy) Invalid Upcast Comparisons (Rust Clippy) Io Other Error (Rust Clippy) Ip Constant (Rust Clippy) Is Digit Ascii Radix (Rust Clippy) Items After Statements (Rust Clippy) Items After Test Module (Rust Clippy) Iter Cloned Collect (Rust Clippy) Iter Count (Rust Clippy) Iter Filter Is Ok (Rust Clippy) Iter Filter Is Some (Rust Clippy) Iter Kv Map (Rust Clippy) Iter Next Slice (Rust Clippy) Iter Not Returning Iterator (Rust Clippy) Iter Nth (Rust Clippy) Iter Nth Zero (Rust Clippy) Iter Over Hash Type (Rust Clippy) Iter Overeager Cloned (Rust Clippy) Iter Skip Next (Rust Clippy) Iter With Drain (Rust Clippy) Iter Without Into Iter (Rust Clippy) Iter on Empty Collections (Rust Clippy) Iter on Single Items (Rust Clippy) Just Underscores and Digits (Rust Clippy) Large Const Arrays (Rust Clippy) Large Digit Groups (Rust Clippy) Large Enum Variant (Rust Clippy) Large Futures (Rust Clippy) Large Include File (Rust Clippy) Large Stack Arrays (Rust Clippy) Large Stack Frames (Rust Clippy) Large Types Passed By Value (Rust Clippy) Legacy Numeric Constants (Rust Clippy) Len Without Is Empty (Rust Clippy) Len Zero (Rust Clippy) Let Underscore Must Use (Rust Clippy) Let Underscore Untyped (Rust Clippy) Let Unit Value (Rust Clippy) Let With Type Underscore (Rust Clippy) Let and Return (Rust Clippy) Linkedlist (Rust Clippy) Little Endian Bytes (Rust Clippy) Lossy Float Literal (Rust Clippy) Macro Metavars in Unsafe (Rust Clippy) Macro Use Imports (Rust Clippy) Main Recursion (Rust Clippy) Manual Abs Diff (Rust Clippy) Manual Assert (Rust Clippy) Manual Async Fn (Rust Clippy) Manual Bits (Rust Clippy) Manual C Str Literals (Rust Clippy) Manual Clamp (Rust Clippy) Manual Contains (Rust Clippy) Manual Dangling Ptr (Rust Clippy) Manual Div Ceil (Rust Clippy) Manual Filter (Rust Clippy) Manual Filter Map (Rust Clippy) Manual Find (Rust Clippy) Manual Find Map (Rust Clippy) Manual Flatten (Rust Clippy) Manual Hash One (Rust Clippy) Manual Ignore Case Cmp (Rust Clippy) Manual Instant Elapsed (Rust Clippy) Manual Is Ascii Check (Rust Clippy) Manual Is Finite (Rust Clippy) Manual Is Infinite (Rust Clippy) Manual Is Power of Two (Rust Clippy) Manual Is Variant and (Rust Clippy) Manual Let Else (Rust Clippy) Manual Main Separator Str (Rust Clippy) Manual Map (Rust Clippy) Manual Memcpy (Rust Clippy) Manual Midpoint (Rust Clippy) Manual Next Back (Rust Clippy) Manual Non Exhaustive (Rust Clippy) Manual Ok Err (Rust Clippy) Manual Ok or (Rust Clippy) Manual Option As Slice (Rust Clippy) Manual Pattern Char Comparison (Rust Clippy) Manual Range Contains (Rust Clippy) Manual Range Patterns (Rust Clippy) Manual Rem Euclid (Rust Clippy) Manual Repeat N (Rust Clippy) Manual Retain (Rust Clippy) Manual Rotate (Rust Clippy) Manual Saturating Arithmetic (Rust Clippy) Manual Slice Fill (Rust Clippy) Manual Slice Size Calculation (Rust Clippy) Manual Split Once (Rust Clippy) Manual Str Repeat (Rust Clippy) Manual String New (Rust Clippy) Manual Strip (Rust Clippy) Manual Swap (Rust Clippy) Manual Try Fold (Rust Clippy) Manual Unwrap or (Rust Clippy) Manual Unwrap or Default (Rust Clippy) Manual While Let Some (Rust Clippy) Many Single Char Names (Rust Clippy) Map Clone (Rust Clippy) Map Collect Result Unit (Rust Clippy) Map Entry (Rust Clippy) Map Err Ignore (Rust Clippy) Map Flatten (Rust Clippy) Map Identity (Rust Clippy) Map Unwrap or (Rust Clippy) Map With Unused Argument Over Ranges (Rust Clippy) Match As Ref (Rust Clippy) Match Bool (Rust Clippy) Match Like Matches Macro (Rust Clippy) Match Overlapping Arm (Rust Clippy) Match Ref Pats (Rust Clippy) Match Result Ok (Rust Clippy) Match Same Arms (Rust Clippy) Match Single Binding (Rust Clippy) Match Wild Err Arm (Rust Clippy) Match Wildcard for Single Variants (Rust Clippy) Match on Vec Items (Rust Clippy) Maybe Infinite Iter (Rust Clippy) Mem Forget (Rust Clippy) Mem Replace Option With None (Rust Clippy) Mem Replace Option With Some (Rust Clippy) Mem Replace With Default (Rust Clippy) Min Ident Chars (Rust Clippy) Misaligned Transmute (Rust Clippy) Mismatching Type Param Order (Rust Clippy) Missing Assert Message (Rust Clippy) Missing Asserts for Indexing (Rust Clippy) Missing Const for Fn (Rust Clippy) Missing Const for Thread Local (Rust Clippy) Missing Docs in Private Items (Rust Clippy) Missing Enforced Import Renames (Rust Clippy) Missing Errors Doc (Rust Clippy) Missing Fields in Debug (Rust Clippy) Missing Inline in Public Items (Rust Clippy) Missing Panics Doc (Rust Clippy) Missing Safety Doc (Rust Clippy) Missing Spin Loop (Rust Clippy) Missing Trait Methods (Rust Clippy) Mixed Attributes Style (Rust Clippy) Mixed Case Hex Literals (Rust Clippy) Mixed Read Write in Expression (Rust Clippy) Mod Module Files (Rust Clippy) Module Inception (Rust Clippy) Module Name Repetitions (Rust Clippy) Modulo Arithmetic (Rust Clippy) Multiple Bound Locations (Rust Clippy) Multiple Crate Versions (Rust Clippy) Multiple Inherent Impl (Rust Clippy) Multiple Unsafe Ops Per Block (Rust Clippy) Must Use Candidate (Rust Clippy) Must Use Unit (Rust Clippy) Mut Mut (Rust Clippy) Mut Mutex Lock (Rust Clippy) Mutex Atomic (Rust Clippy) Mutex Integer (Rust Clippy) Naive Bytecount (Rust Clippy) Needless Arbitrary Self Type (Rust Clippy) Needless Bitwise Bool (Rust Clippy) Needless Bool (Rust Clippy) Needless Bool Assign (Rust Clippy) Needless Borrow (Rust Clippy) Needless Borrowed Reference (Rust Clippy) Needless Borrows for Generic Args (Rust Clippy) Needless Character Iteration (Rust Clippy) Needless Collect (Rust Clippy) Needless Continue (Rust Clippy) Needless Doctest Main (Rust Clippy) Needless Else (Rust Clippy) Needless Late Init (Rust Clippy) Needless Match (Rust Clippy) Needless Option As Deref (Rust Clippy) Needless Option Take (Rust Clippy) Needless Parens on Range Literals (Rust Clippy) Needless Pass By Ref Mut (Rust Clippy) Needless Pass By Value (Rust Clippy) Needless Pub Self (Rust Clippy) Needless Question Mark (Rust Clippy) Needless Range Loop (Rust Clippy) Needless Raw String Hashes (Rust Clippy) Needless Raw Strings (Rust Clippy) Needless Return (Rust Clippy) Needless Return With Question Mark (Rust Clippy) Needless Splitn (Rust Clippy) Needless Update (Rust Clippy) Needless for Each (Rust Clippy) Neg Multiply (Rust Clippy) Negative Feature Names (Rust Clippy) New Ret No Self (Rust Clippy) New Without Default (Rust Clippy) No Effect Underscore Binding (Rust Clippy) No Mangle With Rust Abi (Rust Clippy) Non Ascii Literal (Rust Clippy) Non Minimal Cfg (Rust Clippy) Non Send Fields in Send Ty (Rust Clippy) Non Std Lazy Statics (Rust Clippy) Non Zero Suggestions (Rust Clippy) Nonminimal Bool (Rust Clippy) Nonstandard Macro Braces (Rust Clippy) Obfuscated If Else (Rust Clippy) Ok Expect (Rust Clippy) Op Ref (Rust Clippy) Option As Ref Cloned (Rust Clippy) Option As Ref Deref (Rust Clippy) Option Filter Map (Rust Clippy) Option If Let Else (Rust Clippy) Option Map Unit Fn (Rust Clippy) Option Map or Err Ok (Rust Clippy) Option Map or None (Rust Clippy) Option Option (Rust Clippy) Or Fun Call (Rust Clippy) Or Then Unwrap (Rust Clippy) Owned Cow (Rust Clippy) Panic (Rust Clippy) Panic in Result Fn (Rust Clippy) Partial Pub Fields (Rust Clippy) Partialeq to None (Rust Clippy) Path Buf Push Overwrite (Rust Clippy) Pathbuf Init Then Push (Rust Clippy) Pattern Type Mismatch (Rust Clippy) Pointers in Nomem Asm Block (Rust Clippy) Precedence (Rust Clippy) Precedence Bits (Rust Clippy) Print Literal (Rust Clippy) Print Stderr (Rust Clippy) Print Stdout (Rust Clippy) Print With Newline (Rust Clippy) Println Empty String (Rust Clippy) Ptr Arg (Rust Clippy) Ptr As Ptr (Rust Clippy) Ptr Cast Constness (Rust Clippy) Ptr Eq (Rust Clippy) Ptr Offset With Cast (Rust Clippy) Pub Enum Variant Names (Rust Clippy) Pub Underscore Fields (Rust Clippy) Pub Use (Rust Clippy) Pub With Shorthand (Rust Clippy) Pub Without Shorthand (Rust Clippy) Question Mark (Rust Clippy) Question Mark Used (Rust Clippy) Range Minus One (Rust Clippy) Range Plus One (Rust Clippy) Range Step By Zero (Rust Clippy) Range Zip With Len (Rust Clippy) Rc Buffer (Rust Clippy) Rc Mutex (Rust Clippy) Read Zero Byte Vec (Rust Clippy) Readonly Write Lock (Rust Clippy) Redundant Allocation (Rust Clippy) Redundant Closure (Rust Clippy) Redundant Closure for Method Calls (Rust Clippy) Redundant Else (Rust Clippy) Redundant Feature Names (Rust Clippy) Redundant Field Names (Rust Clippy) Redundant Pattern (Rust Clippy) Redundant Pattern Matching (Rust Clippy) Redundant Static Lifetimes (Rust Clippy) Redundant Type Annotations (Rust Clippy) Ref As Ptr (Rust Clippy) Ref Binding to Reference (Rust Clippy) Ref Option (Rust Clippy) Ref Option Ref (Rust Clippy) Ref Patterns (Rust Clippy) Regex Creation in Loops (Rust Clippy) Regex Macro (Rust Clippy) Renamed Function Params (Rust Clippy) Repeat Once (Rust Clippy) Replace Consts (Rust Clippy) Reserve After Initialization (Rust Clippy) Rest Pat in Fully Bound Structs (Rust Clippy) Result Filter Map (Rust Clippy) Result Large Err (Rust Clippy) Result Map Unit Fn (Rust Clippy) Result Map or Into Option (Rust Clippy) Result Unit Err (Rust Clippy) Return Self Not Must Use (Rust Clippy) Return and Then (Rust Clippy) Same Functions in If Condition (Rust Clippy) Same Item Push (Rust Clippy) Same Name Method (Rust Clippy) Search Is Some (Rust Clippy) Seek From Current (Rust Clippy) Seek to Start Instead of Rewind (Rust Clippy) Self Named Constructors (Rust Clippy) Self Named Module Files (Rust Clippy) Semicolon If Nothing Returned (Rust Clippy) Semicolon Inside Block (Rust Clippy) Semicolon Outside Block (Rust Clippy) Separated Literal Suffix (Rust Clippy) Set Contains or Insert (Rust Clippy) Shadow Reuse (Rust Clippy) Shadow Same (Rust Clippy) Shadow Unrelated (Rust Clippy) Short Circuit Statement (Rust Clippy) Should Assert Eq (Rust Clippy) Should Implement Trait (Rust Clippy) Should Panic Without Expect (Rust Clippy) Significant Drop Tightening (Rust Clippy) Significant Drop in Scrutinee (Rust Clippy) Similar Names (Rust Clippy) Single Call Fn (Rust Clippy) Single Char Add Str (Rust Clippy) Single Char Lifetime Names (Rust Clippy) Single Char Pattern (Rust Clippy) Single Component Path Imports (Rust Clippy) Single Element Loop (Rust Clippy) Single Match (Rust Clippy) Single Match Else (Rust Clippy) Single Option Map (Rust Clippy) Skip While Next (Rust Clippy) Slow Vector Initialization (Rust Clippy) Stable Sort Primitive (Rust Clippy) Std Instead of Alloc (Rust Clippy) Std Instead of Core (Rust Clippy) Str Split at Newline (Rust Clippy) Str to String (Rust Clippy) String Add (Rust Clippy) String Add Assign (Rust Clippy) String Extend Chars (Rust Clippy) String From Utf8 As Bytes (Rust Clippy) String Lit As Bytes (Rust Clippy) String Lit Chars Any (Rust Clippy) String Slice (Rust Clippy) String to String (Rust Clippy) Strlen on C Strings (Rust Clippy) Struct Excessive Bools (Rust Clippy) Struct Field Names (Rust Clippy) Suboptimal Flops (Rust Clippy) Suspicious Xor Used As Pow (Rust Clippy) Tabs in Doc Comments (Rust Clippy) Tests Outside Test Module (Rust Clippy) To Digit Is Some (Rust Clippy) To String Trait Impl (Rust Clippy) To String in Format Args (Rust Clippy) Todo (Rust Clippy) Too Long First Doc Paragraph (Rust Clippy) Too Many Arguments (Rust Clippy) Too Many Lines (Rust Clippy) Toplevel Ref Arg (Rust Clippy) Trait Duplication in Bounds (Rust Clippy) Transmute Bytes to Str (Rust Clippy) Transmute Int to Bool (Rust Clippy) Transmute Int to Non Zero (Rust Clippy) Transmute Ptr to Ptr (Rust Clippy) Transmute Ptr to Ref (Rust Clippy) Transmute Undefined Repr (Rust Clippy) Transmutes Expressible As Ptr Casts (Rust Clippy) Trim Split Whitespace (Rust Clippy) Trivial Regex (Rust Clippy) Trivially Copy Pass By Ref (Rust Clippy) Try Err (Rust Clippy) Tuple Array Conversions (Rust Clippy) Type Complexity (Rust Clippy) Type Repetition in Bounds (Rust Clippy) Unchecked Duration Subtraction (Rust Clippy) Undocumented Unsafe Blocks (Rust Clippy) Unicode Not Nfc (Rust Clippy) Unimplemented (Rust Clippy) Uninlined Format Args (Rust Clippy) Unit Arg (Rust Clippy) Unnecessary Box Returns (Rust Clippy) Unnecessary Cast (Rust Clippy) Unnecessary Debug Formatting (Rust Clippy) Unnecessary Fallible Conversions (Rust Clippy) Unnecessary Filter Map (Rust Clippy) Unnecessary Find Map (Rust Clippy) Unnecessary First Then Check (Rust Clippy) Unnecessary Fold (Rust Clippy) Unnecessary Get Then Check (Rust Clippy) Unnecessary Join (Rust Clippy) Unnecessary Lazy Evaluations (Rust Clippy) Unnecessary Literal Bound (Rust Clippy) Unnecessary Literal Unwrap (Rust Clippy) Unnecessary Map on Constructor (Rust Clippy) Unnecessary Map or (Rust Clippy) Unnecessary Mut Passed (Rust Clippy) Unnecessary Operation (Rust Clippy) Unnecessary Owned Empty Strings (Rust Clippy) Unnecessary Result Map or Else (Rust Clippy) Unnecessary Safety Comment (Rust Clippy) Unnecessary Safety Doc (Rust Clippy) Unnecessary Self Imports (Rust Clippy) Unnecessary Semicolon (Rust Clippy) Unnecessary Sort By (Rust Clippy) Unnecessary Struct Initialization (Rust Clippy) Unnecessary Unwrap (Rust Clippy) Unnecessary Wraps (Rust Clippy) Unnecessary to Owned (Rust Clippy) Unneeded Field Pattern (Rust Clippy) Unneeded Struct Pattern (Rust Clippy) Unneeded Wildcard Pattern (Rust Clippy) Unnested or Patterns (Rust Clippy) Unreachable (Rust Clippy) Unreadable Literal (Rust Clippy) Unsafe Derive Deserialize (Rust Clippy) Unsafe Removed From Name (Rust Clippy) Unsafe Vector Initialization (Rust Clippy) Unseparated Literal Suffix (Rust Clippy) Unstable As Mut Slice (Rust Clippy) Unstable As Slice (Rust Clippy) Unused Async (Rust Clippy) Unused Collect (Rust Clippy) Unused Enumerate Index (Rust Clippy) Unused Format Specs (Rust Clippy) Unused Self (Rust Clippy) Unused Unit (Rust Clippy) Unusual Byte Groupings (Rust Clippy) Unwrap Used (Rust Clippy) Unwrap in Result (Rust Clippy) Unwrap or Default (Rust Clippy) Upper Case Acronyms (Rust Clippy) Use Debug (Rust Clippy) Use Self (Rust Clippy) Used Underscore Binding (Rust Clippy) Used Underscore Items (Rust Clippy) Useless Let If Seq (Rust Clippy) Useless Vec (Rust Clippy) Vec Box (Rust Clippy) Vec Init Then Push (Rust Clippy) Verbose Bit Mask (Rust Clippy) Verbose File Reads (Rust Clippy) Waker Clone Wake (Rust Clippy) While Let Loop (Rust Clippy) While Let on Iterator (Rust Clippy) Wildcard Dependencies (Rust Clippy) Wildcard Enum Match Arm (Rust Clippy) Wildcard Imports (Rust Clippy) Wildcard in or Patterns (Rust Clippy) Write Literal (Rust Clippy) Write With Newline (Rust Clippy) Writeln Empty String (Rust Clippy) Wrong Pub Self Convention (Rust Clippy) Wrong Self Convention (Rust Clippy) Zero Divided By Zero (Rust Clippy) Zero Prefixed Literal (Rust Clippy) Zero Ptr (Rust Clippy) Zero Sized Map Values (Rust Clippy)	Accessor Pairs (ESLint) Array Bracket Newline (ESLint) Array Bracket Spacing (ESLint) Array Element Newline (ESLint) Arrow Body Style (ESLint) Arrow Parens (ESLint) Arrow Spacing (ESLint) Block Scoped Var (ESLint) Block Spacing (ESLint) Brace Style (ESLint) Callback Return (ESLint) Camelcase (ESLint) Capitalized Comments (ESLint) Class Methods Use This (ESLint) Comma Dangle (ESLint) Comma Spacing (ESLint) Comma Style (ESLint) Complexity (ESLint) Computed Property Spacing (ESLint) Consistent Return (ESLint) Consistent This (ESLint) Curly (ESLint) Default Case (ESLint) Default Case Last (ESLint) Default Param Last (ESLint) Dot Location (ESLint) Dot Notation (ESLint) Eol Last (ESLint) Equal-Equal-Equal (ESLint) Func Call Spacing (ESLint) Func Name Matching (ESLint) Func Names (ESLint) Func Style (ESLint) Function Call Argument Newline (ESLint) Function Paren Newline (ESLint) Generator Star Spacing (ESLint) Global Require (ESLint) Grouped Accessor Pairs (ESLint) Guard for in (ESLint) Handle Callback Err (ESLint) Id Blacklist (ESLint) Id Denylist (ESLint) Id Length (ESLint) Id Match (ESLint) Implicit Arrow Linebreak (ESLint) Indent (ESLint) Indent Legacy (ESLint) Init Declarations (ESLint) Jsx Quotes (ESLint) Key Spacing (ESLint) Keyword Spacing (ESLint) Line Comment Position (ESLint) Linebreak Style (ESLint) Lines Around Comment (ESLint) Lines Around Directive (ESLint) Lines Between Class Members (ESLint) Logical Assignment Operators (ESLint) Max Classes Per File (ESLint) Max Depth (ESLint) Max Len (ESLint) Max Lines (ESLint) Max Lines Per Function (ESLint) Max Nested Callbacks (ESLint) Max Params (ESLint) Max Statements (ESLint) Max Statements Per Line (ESLint) Multiline Comment Style (ESLint) Multiline Ternary (ESLint) New Cap (ESLint) New Parens (ESLint) Newline After Var (ESLint) Newline Before Return (ESLint) Newline Per Chained Call (ESLint) No Alert (ESLint) No Array Constructor (ESLint) No Async Promise Executor (ESLint) No Await in Loop (ESLint) No Bitwise (ESLint) No Buffer Constructor (ESLint) No Caller (ESLint) No Case Declarations (ESLint) No Catch Shadow (ESLint) No Class Assign (ESLint) No Compare Neg Zero (ESLint) No Cond Assign (ESLint) No Confusing Arrow (ESLint) No Console (ESLint) No Const Assign (ESLint) No Constant Binary Expression (ESLint) No Constant Condition (ESLint) No Constructor Return (ESLint) No Continue (ESLint) No Control Regex (ESLint) No Debugger (ESLint) No Delete Var (ESLint) No Div Regex (ESLint) No Else Return (ESLint) No Ex Assign (ESLint) No Extend Native (ESLint) No Extra Parens (ESLint) No Fallthrough (ESLint) No Floating Decimal (ESLint) No Func Assign (ESLint) No Global Assign (ESLint) No Implicit Coercion (ESLint) No Implicit Globals (ESLint) No Implied Eval (ESLint) No Import Assign (ESLint) No Inline Comments (ESLint) No Inner Declarations (ESLint) No Invalid Regexp (ESLint) No Invalid This (ESLint) No Irregular Whitespace (ESLint) No Iterator (ESLint) No Label Var (ESLint) No Labels (ESLint) No Lone Blocks (ESLint) No Lonely If (ESLint) No Loop Func (ESLint) No Loss of Precision (ESLint) No Magic Numbers (ESLint) No Misleading Character Class (ESLint) No Mixed Operators (ESLint) No Mixed Requires (ESLint) No Mixed Spaces and Tabs (ESLint) No Multi Assign (ESLint) No Multi Spaces (ESLint) No Multi Str (ESLint) No Multiple Empty Lines (ESLint) No Native Reassign (ESLint) No Negated Condition (ESLint) No Negated in Lhs (ESLint) No Nested Ternary (ESLint) No New (ESLint) No New Func (ESLint) No New Native Nonconstructor (ESLint) No New Object (ESLint) No New Require (ESLint) No New Symbol (ESLint) No New Wrappers (ESLint) No Nonoctal Decimal Escape (ESLint) No Obj Calls (ESLint) No Object Constructor (ESLint) No Octal (ESLint) No Octal Escape (ESLint) No Param Reassign (ESLint) No Path Concat (ESLint) No Plusplus (ESLint) No Process Env (ESLint) No Process Exit (ESLint) No Promise Executor Return (ESLint) No Proto (ESLint) No Prototype Builtins (ESLint) No Redeclare (ESLint) No Regex Spaces (ESLint) No Restricted Exports (ESLint) No Restricted Globals (ESLint) No Restricted Imports (ESLint) No Restricted Modules (ESLint) No Restricted Properties (ESLint) No Restricted Syntax (ESLint) No Return Assign (ESLint) No Return Await (ESLint) No Script Url (ESLint) No Sequences (ESLint) No Setter Return (ESLint) No Shadow (ESLint) No Shadow Restricted Names (ESLint) No Spaced Func (ESLint) No Sparse Arrays (ESLint) No Sync (ESLint) No Tabs (ESLint) No Template Curly in String (ESLint) No Ternary (ESLint) No This Before Super (ESLint) No Throw Literal (ESLint) No Trailing Spaces (ESLint) No Undef (ESLint) No Undef Init (ESLint) No Undefined (ESLint) No Underscore Dangle (ESLint) No Unexpected Multiline (ESLint) No Unmodified Loop Condition (ESLint) No Unsafe Finally (ESLint) No Unsafe Negation (ESLint) No Unsafe Optional Chaining (ESLint) No Unused Private Class Members (ESLint) No Use Before Define (ESLint) No Var (ESLint) No Void (ESLint) No Warning Comments (ESLint) No Whitespace Before Property (ESLint) No With (ESLint) Nonblock Statement Body Position (ESLint) Object Curly Newline (ESLint) Object Curly Spacing (ESLint) Object Property Newline (ESLint) Object Shorthand (ESLint) One Var (ESLint) One Var Declaration Per Line (ESLint) Operator Assignment (ESLint) Operator Linebreak (ESLint) Padded Blocks (ESLint) Padding Line Between Statements (ESLint) Prefer Arrow Callback (ESLint) Prefer Const (ESLint) Prefer Destructuring (ESLint) Prefer Exponentiation Operator (ESLint) Prefer Named Capture Group (ESLint) Prefer Numeric Literals (ESLint) Prefer Object Has Own (ESLint) Prefer Object Spread (ESLint) Prefer Promise Reject Errors (ESLint) Prefer Reflect (ESLint) Prefer Regex Literals (ESLint) Prefer Rest Params (ESLint) Prefer Spread (ESLint) Prefer Template (ESLint) Quote Props (ESLint) Quotes (ESLint) Radix (ESLint) Require Await (ESLint) Require Jsdoc (ESLint) Require Unicode Regexp (ESLint) Require Yield (ESLint) Rest Spread Spacing (ESLint) Semi (ESLint) Semi Spacing (ESLint) Semi Style (ESLint) Sort Imports (ESLint) Sort Keys (ESLint) Sort Vars (ESLint) Space Before Blocks (ESLint) Space Before Function Paren (ESLint) Space Infix Ops (ESLint) Space Unary Ops (ESLint) Space in Parens (ESLint) Spaced Comment (ESLint) Strict (ESLint) Switch Colon Spacing (ESLint) Symbol Description (ESLint) Template Curly Spacing (ESLint) Template Tag Spacing (ESLint) Unicode Bom (ESLint) Valid Jsdoc (ESLint) Vars on Top (ESLint) Wrap Iife (ESLint) Wrap Regex (ESLint) Yield Star Spacing (ESLint) Yoda (ESLint)	Adjacent Overload Signatures (TS-ESLint) Array Type (TS-ESLint) Ban Ts Comment (TS-ESLint) Ban Tslint Comment (TS-ESLint) Ban Types (TS-ESLint) Block Spacing (TS-ESLint) Brace Style (TS-ESLint) Class Methods Use This (TS-ESLint) Comma Dangle (TS-ESLint) Comma Spacing (TS-ESLint) Consistent Generic Constructors (TS-ESLint) Consistent Indexed Object Style (TS-ESLint) Consistent Type Assertions (TS-ESLint) Consistent Type Definitions (TS-ESLint) Consistent Type Exports (TS-ESLint) Consistent Type Imports (TS-ESLint) Default Param Last (TS-ESLint) Dot Notation (TS-ESLint) Func Call Spacing (TS-ESLint) Indent (TS-ESLint) Init Declarations (TS-ESLint) Key Spacing (TS-ESLint) Keyword Spacing (TS-ESLint) Lines Around Comment (TS-ESLint) Lines Between Class Members (TS-ESLint) Max Params (TS-ESLint) Member Delimiter Style (TS-ESLint) Member Ordering (TS-ESLint) Method Signature Style (TS-ESLint) Naming Convention (TS-ESLint) No Array Constructor (TS-ESLint) No Array Delete (TS-ESLint) No Base to String (TS-ESLint) No Confusing Non Null Assertion (TS-ESLint) No Confusing Void Expression (TS-ESLint) No Dupe Class Members (TS-ESLint) No Duplicate Enum Values (TS-ESLint) No Duplicate Type Constituents (TS-ESLint) No Dynamic Delete (TS-ESLint) No Empty Function (TS-ESLint) No Empty Interface (TS-ESLint) No Explicit Any (TS-ESLint) No Extra Non Null Assertion (TS-ESLint) No Extra Parens (TS-ESLint) No Extra Semi (TS-ESLint) No Extraneous Class (TS-ESLint) No Floating Promises (TS-ESLint) No Implied Eval (TS-ESLint) No Import Type Side Effects (TS-ESLint) No Inferrable Types (TS-ESLint) No Invalid This (TS-ESLint) No Invalid Void Type (TS-ESLint) No Loop Func (TS-ESLint) No Loss of Precision (TS-ESLint) No Magic Numbers (TS-ESLint) No Meaningless Void Operator (TS-ESLint) No Misused New (TS-ESLint) No Misused Promises (TS-ESLint) No Mixed Enums (TS-ESLint) No Namespace (TS-ESLint) No Non Null Asserted Nullish Coalescing (TS-ESLint) No Non Null Asserted Optional Chain (TS-ESLint) No Non Null Assertion (TS-ESLint) No Redeclare (TS-ESLint) No Redundant Type Constituents (TS-ESLint) No Require Imports (TS-ESLint) No Restricted Imports (TS-ESLint) No Shadow (TS-ESLint) No This Alias (TS-ESLint) No Throw Literal (TS-ESLint) No Type Alias (TS-ESLint) No Unnecessary Boolean Literal Compare (TS-ESLint) No Unnecessary Condition (TS-ESLint) No Unnecessary Qualifier (TS-ESLint) No Unnecessary Type Arguments (TS-ESLint) No Unnecessary Type Assertion (TS-ESLint) No Unnecessary Type Constraint (TS-ESLint) No Unsafe Argument (TS-ESLint) No Unsafe Assignment (TS-ESLint) No Unsafe Call (TS-ESLint) No Unsafe Declaration Merging (TS-ESLint) No Unsafe Enum Comparison (TS-ESLint) No Unsafe Member Access (TS-ESLint) No Unsafe Return (TS-ESLint) No Unsafe Unary Minus (TS-ESLint) No Unused Expressions (TS-ESLint) No Use Before Define (TS-ESLint) No Var Requires (TS-ESLint) No for in Array (TS-ESLint) Non Nullable Type Assertion Style (TS-ESLint) Object Curly Spacing (TS-ESLint) Padding Line Between Statements (TS-ESLint) Prefer As Const (TS-ESLint) Prefer Destructuring (TS-ESLint) Prefer Enum Initializers (TS-ESLint) Prefer Find (TS-ESLint) Prefer Function Type (TS-ESLint) Prefer Includes (TS-ESLint) Prefer Literal Enum Member (TS-ESLint) Prefer Namespace Keyword (TS-ESLint) Prefer Nullish Coalescing (TS-ESLint) Prefer Optional Chain (TS-ESLint) Prefer Promise Reject Errors (TS-ESLint) Prefer Readonly (TS-ESLint) Prefer Readonly Parameter Types (TS-ESLint) Prefer Reduce Type Parameter (TS-ESLint) Prefer Regexp Exec (TS-ESLint) Prefer Return This Type (TS-ESLint) Prefer String Starts Ends With (TS-ESLint) Prefer Ts Expect Error (TS-ESLint) Prefer for of (TS-ESLint) Promise Function Async (TS-ESLint) Quotes (TS-ESLint) Require Await (TS-ESLint) Restrict Plus Operands (TS-ESLint) Semi (TS-ESLint) Sort Type Constituents (TS-ESLint) Space Before Blocks (TS-ESLint) Space Before Function Paren (TS-ESLint) Space Infix Ops (TS-ESLint) Strict Boolean Expressions (TS-ESLint) Switch Exhaustiveness Check (TS-ESLint) Triple Slash Reference (TS-ESLint) Type Annotation Spacing (TS-ESLint) Typedef (TS-ESLint) Unified Signatures (TS-ESLint)

To report problems with this documentation, please visit https://support.codesecure.com/.