.editorconfig

# editorconfig.org

# top-most EditorConfig file
root = true

#############################################
# Default settings
#############################################
[*]
end_of_line = lf
insert_final_newline = true
indent_style = space
indent_size = 4

[project.json]
indent_size = 2

#############################################
# C# Code Style Settings
#############################################
[*.cs]

###################
# New line preferences
###################
csharp_new_line_before_open_brace = all
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_between_query_expression_clauses = true

###################
# Indentation preferences
###################
csharp_indent_block_contents = true
csharp_indent_braces = false
csharp_indent_case_contents = true
csharp_indent_case_contents_when_block = true
csharp_indent_switch_labels = true
csharp_indent_labels = one_less_than_current

###################
# Modifier preferences
###################
csharp_preferred_modifier_order = public, private, protected, internal, static, extern, new, virtual, abstract, sealed, override, readonly, unsafe, volatile, async:suggestion

###################
# 'this.' qualification
###################
dotnet_style_qualification_for_field = false:suggestion
dotnet_style_qualification_for_property = false:suggestion
dotnet_style_qualification_for_method = false:suggestion
dotnet_style_qualification_for_event = false:suggestion

###################
# 'var' preferences
###################
csharp_style_var_for_built_in_types = true:suggestion
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = true:suggestion

###################
# Predefined type preferences
###################
dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
dotnet_style_predefined_type_for_member_access = true:suggestion

###################
# Naming conventions
###################

# Constant fields should be PascalCase
dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols = constant_fields
dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style
dotnet_naming_symbols.constant_fields.applicable_kinds = field
dotnet_naming_symbols.constant_fields.required_modifiers = const
dotnet_naming_style.pascal_case_style.capitalization = pascal_case

# Local constants should be PascalCase
dotnet_naming_rule.local_constants_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.local_constants_should_be_pascal_case.symbols = local_constants
dotnet_naming_rule.local_constants_should_be_pascal_case.style = pascal_case_style
dotnet_naming_symbols.local_constants.applicable_kinds = local
dotnet_naming_symbols.local_constants.required_modifiers = const

# Static fields should have s_ prefix
dotnet_naming_rule.static_fields_should_have_prefix.severity = none
dotnet_naming_rule.static_fields_should_have_prefix.symbols = static_fields
dotnet_naming_rule.static_fields_should_have_prefix.style = static_prefix_style
dotnet_naming_symbols.static_fields.applicable_kinds = field
dotnet_naming_symbols.static_fields.required_modifiers = static
dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected
dotnet_naming_style.static_prefix_style.required_prefix = s_
dotnet_naming_style.static_prefix_style.capitalization = camel_case

# Internal and private fields should be _camelCase
dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
dotnet_naming_rule.camel_case_for_private_internal_fields.symbols = private_internal_fields
dotnet_naming_rule.camel_case_for_private_internal_fields.style = camel_case_underscore_style
dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
dotnet_naming_style.camel_case_underscore_style.required_prefix = _
dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case

###################
# Code style defaults
###################
csharp_using_directive_placement = outside_namespace:suggestion
dotnet_sort_system_directives_first = true
csharp_prefer_braces = true:silent
csharp_preserve_single_line_blocks = true:none
csharp_preserve_single_line_statements = false:none

###################
# Code quality
###################
dotnet_code_quality_unused_parameters = non_public:suggestion

###################
# Expression-level preferences
###################
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_prefer_auto_properties = true:suggestion
dotnet_style_prefer_conditional_expression_over_assignment = true:silent
dotnet_style_prefer_conditional_expression_over_return = true:silent

###################
# Expression-bodied members
###################
csharp_style_expression_bodied_methods = true:suggestion
csharp_style_expression_bodied_constructors = true:suggestion
csharp_style_expression_bodied_operators = true:suggestion
csharp_style_expression_bodied_properties = true:suggestion
csharp_style_expression_bodied_indexers = true:suggestion
csharp_style_expression_bodied_accessors = true:suggestion
csharp_style_expression_bodied_lambdas = true:suggestion
csharp_style_expression_bodied_local_functions = true:suggestion

###################
# Other features
###################
csharp_style_prefer_index_operator = false:none
csharp_style_prefer_range_operator = false:none
csharp_style_pattern_local_over_anonymous_function = false:none

###################
# Space preferences
###################
csharp_space_after_cast = false
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_after_comma = true
csharp_space_after_dot = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_after_semicolon_in_for_statement = true
csharp_space_around_binary_operators = before_and_after
csharp_space_around_declaration_statements = do_not_ignore
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_before_comma = false
csharp_space_before_dot = false
csharp_space_before_open_square_brackets = false
csharp_space_before_semicolon_in_for_statement = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_parentheses = false
csharp_space_between_square_brackets = false

#############################################
# Code Analyzers
#############################################

###################
# Custom Analyzers
###################
dotnet_diagnostic.AvoidAsyncVoid.severity = suggestion

###################
# Microsoft.CodeAnalysis.NetAnalyzers (CA)
###################
# Design
dotnet_diagnostic.CA1000.severity = none # Do not declare static members on generic types — common factory pattern
dotnet_diagnostic.CA1001.severity = error # Types that own disposable fields should be disposable
dotnet_diagnostic.CA1002.severity = none # Do not expose generic lists — we deliberately expose List<T>; interface-based collections are an older convention we don't follow
dotnet_diagnostic.CA1003.severity = none # Use generic event handler instances — covered by SST2304
dotnet_diagnostic.CA1005.severity = none # Avoid excessive parameters on generic types — we deliberately expose 3+ type-parameter types (tuple-style handles, raw engine signals); the ergonomic guidance conflicts with that design
dotnet_diagnostic.CA1008.severity = error # Enums should have zero value
dotnet_diagnostic.CA1010.severity = none # Collections should implement generic interface — we deliberately expose concrete collection types; interface-based collections are an older convention we don't follow
dotnet_diagnostic.CA1012.severity = none # Abstract types should not have public constructors — covered by SST1428
dotnet_diagnostic.CA1014.severity = none # Mark assemblies with CLSCompliantAttribute — we don't ship CLS-compliant assemblies
dotnet_diagnostic.CA1016.severity = error # Mark assemblies with AssemblyVersionAttribute
dotnet_diagnostic.CA1017.severity = none # Mark assemblies with ComVisibleAttribute — we don't ship COM-visible assemblies
dotnet_diagnostic.CA1018.severity = error # Mark attributes with AttributeUsageAttribute
dotnet_diagnostic.CA1019.severity = none # Define accessors for attribute arguments — conflicts with SST2324, which caps an internal attribute's accessor at internal
dotnet_diagnostic.CA1021.severity = none # Avoid out parameters - disabled - needed for the zero-allocation idiom in Try/Find APIs and other performance-critical paths
dotnet_diagnostic.CA1024.severity = error # Use properties where appropriate
dotnet_diagnostic.CA1027.severity = error # Mark enums with FlagsAttribute
dotnet_diagnostic.CA1028.severity = none # Enum storage should be Int32 — covered by SST2313
dotnet_diagnostic.CA1030.severity = none # Use events where appropriate — we use Rx observables instead of CLR events
dotnet_diagnostic.CA1031.severity = none # Do not catch general exception types — required at logging/dispose/IO boundaries
dotnet_diagnostic.CA1032.severity = none # Implement standard exception constructors — covered by SST1488
dotnet_diagnostic.CA1033.severity = none # Interface methods should be callable by child types — explicit interface implementations are a deliberate design choice
dotnet_diagnostic.CA1034.severity = none # Nested types should not be visible — public nested types are sometimes the cleanest API (e.g. interface-scoped exception helpers)
dotnet_diagnostic.CA1036.severity = none # Override methods on comparable types — relational operators rarely meaningful for our types
dotnet_diagnostic.CA1040.severity = none # Avoid empty interfaces — duplicate of SST1437 (canonical); marker interfaces (IActivatableView etc.) are deliberate public API
dotnet_diagnostic.CA1041.severity = none # Provide ObsoleteAttribute message — covered by SST2308
dotnet_diagnostic.CA1043.severity = error # Use integral or string argument for indexers
dotnet_diagnostic.CA1044.severity = none # Properties should not be write only — covered by SST1421
dotnet_diagnostic.CA1045.severity = none # Do not pass types by reference — we deliberately use ref-passing static helpers so they carry only the data they touch; data-oriented layout is the default here
dotnet_diagnostic.CA1046.severity = error # Do not overload operator equals on reference types
dotnet_diagnostic.CA1047.severity = none # Do not declare protected member in sealed type — covered by SST1427
dotnet_diagnostic.CA1048.severity = none # Do not declare virtual members in sealed types — covered by SST1491
dotnet_diagnostic.CA1050.severity = none # Declare types in namespaces — covered by SST2312
dotnet_diagnostic.CA1051.severity = none # Duplicate of SST1401 (canonical) — do not declare visible instance fields
dotnet_diagnostic.CA1052.severity = none # Static holder types should be sealed — covered by SST1432
dotnet_diagnostic.CA1053.severity = none # Static holder types should not have constructors — covered by SST1432
dotnet_diagnostic.CA1054.severity = suggestion # URI parameters should not be strings
dotnet_diagnostic.CA1055.severity = suggestion # URI return values should not be strings
dotnet_diagnostic.CA1056.severity = suggestion # URI properties should not be strings
dotnet_diagnostic.CA1058.severity = error # Types should not extend certain base types
dotnet_diagnostic.CA1059.severity = error # Members should not expose certain concrete types
dotnet_diagnostic.CA1060.severity = error # Move P/Invokes to NativeMethods class
dotnet_diagnostic.CA1061.severity = none # Do not hide base class methods — covered by SST2427
dotnet_diagnostic.CA1062.severity = none # Validate arguments of public methods - Nullable=enable + we own every consumer, so the compiler already guarantees non-null params
dotnet_diagnostic.CA1063.severity = none # Implement IDisposable correctly — covered by SST2300
dotnet_diagnostic.CA1064.severity = error # Exceptions should be public
dotnet_diagnostic.CA1065.severity = none # Do not raise exceptions in unexpected locations — covered by SST1485
dotnet_diagnostic.CA1066.severity = error # Implement IEquatable when overriding Equals
dotnet_diagnostic.CA1067.severity = error # Override Equals when implementing IEquatable
dotnet_diagnostic.CA1068.severity = error # CancellationToken parameters must come last
dotnet_diagnostic.CA1069.severity = error # Enums should not have duplicate values
dotnet_diagnostic.CA1070.severity = error # Do not declare event fields as virtual

# Globalization
dotnet_diagnostic.CA1303.severity = none # Do not pass literals as localized parameters — we don't ship localized resources
dotnet_diagnostic.CA1307.severity = none # Covered by PSH1207 (canonical)
dotnet_diagnostic.CA1308.severity = none # Normalize strings to uppercase — ToLowerInvariant is correct for filesystem path / cache key normalization
dotnet_diagnostic.CA1310.severity = none # Covered by PSH1207 (canonical)

# Interoperability
dotnet_diagnostic.CA1401.severity = error # P/Invokes should not be visible

# Maintainability
dotnet_diagnostic.CA1500.severity = none # Variable names should not match field names — covered by SST1484
dotnet_diagnostic.CA1501.severity = none # Covered by SST1446 (canonical)
dotnet_diagnostic.CA1502.severity = none # Covered by SST1442 (canonical)
dotnet_diagnostic.CA1505.severity = error # Avoid unmaintainable code
dotnet_diagnostic.CA1506.severity = none # Avoid excessive class coupling — adds little signal here, mostly trips on legitimate orchestration code
dotnet_diagnostic.CA1507.severity = none # Use nameof in place of string — covered by SST1463
dotnet_diagnostic.CA1508.severity = error # Avoid dead conditional code
dotnet_diagnostic.CA1509.severity = error # Invalid entry in code metrics configuration file
dotnet_diagnostic.CA1510.severity = none # Covered by PSH1409 (canonical)
dotnet_diagnostic.CA1511.severity = none # Covered by PSH1409 (canonical)
dotnet_diagnostic.CA1512.severity = none # Covered by PSH1409 (canonical)
dotnet_diagnostic.CA1513.severity = none # Covered by PSH1409 (canonical)
dotnet_diagnostic.CA1514.severity = none # Avoid redundant length argument — covered by PSH1220
dotnet_diagnostic.CA1515.severity = none # Consider making public types internal — interferes with tests and reflection-discovered types (BenchmarkDotNet, TUnit, etc.)
dotnet_diagnostic.CA1516.severity = error # Use cross-platform intrinsics

# Naming
dotnet_diagnostic.CA1710.severity = suggestion # Identifiers should have correct suffix
dotnet_diagnostic.CA1724.severity = none # Type Names Should Not Match Namespaces — namespace/type name overlap is intentional API surface

# Performance
dotnet_diagnostic.CA1802.severity = none # Use literals where appropriate — covered by PSH1402
dotnet_diagnostic.CA1805.severity = none # Do not initialize unnecessarily — covered by PSH1403
dotnet_diagnostic.CA1806.severity = error # Do not ignore method results
dotnet_diagnostic.CA1810.severity = none # Initialize reference type static fields inline — explicit static constructors are deliberate in some types
dotnet_diagnostic.CA1812.severity = error # Avoid uninstantiated internal classes
dotnet_diagnostic.CA1813.severity = none # Avoid unsealed attributes — covered by PSH1401
dotnet_diagnostic.CA1814.severity = none # Prefer jagged arrays over multidimensional — covered by PSH1020
dotnet_diagnostic.CA1815.severity = none # Override equals and operator equals on value types — covered by PSH1005
dotnet_diagnostic.CA1819.severity = none # Properties should not return arrays — incompatible with the RxUI/sqlite-net mapping style we use throughout the codebase
dotnet_diagnostic.CA1820.severity = none # Test for empty strings using string length — covered by PSH1204
dotnet_diagnostic.CA1821.severity = none # Remove empty finalizers — covered by PSH1002
dotnet_diagnostic.CA1822.severity = none # Mark members as static — covered by PSH1414
dotnet_diagnostic.CA1823.severity = none # Avoid unused private fields — covered by SST1441
dotnet_diagnostic.CA1824.severity = error # Mark assemblies with NeutralResourcesLanguageAttribute
dotnet_diagnostic.CA1825.severity = none # Avoid zero-length array allocations — covered by PSH1001
dotnet_diagnostic.CA1826.severity = none # Use property instead of Linq Enumerable method — covered by PSH1103
dotnet_diagnostic.CA1827.severity = none # Do not use Count/LongCount when Any can be used — covered by PSH1119
dotnet_diagnostic.CA1828.severity = none # Do not use CountAsync/LongCountAsync when AnyAsync can be used — covered by PSH1126
dotnet_diagnostic.CA1829.severity = none # Use Length/Count property instead of Enumerable.Count — covered by PSH1103
dotnet_diagnostic.CA1830.severity = none # Prefer strongly-typed Append/Insert overloads on StringBuilder — covered by PSH1202
dotnet_diagnostic.CA1831.severity = none # Use AsSpan instead of Range-based indexers for string — covered by PSH1212
dotnet_diagnostic.CA1832.severity = none # Use AsSpan or AsMemory instead of Range-based indexers for getting ReadOnlySpan or ReadOnlyMemory portion of an array — covered by PSH1019
dotnet_diagnostic.CA1833.severity = none # Use AsSpan or AsMemory instead of Range-based indexers for getting Span or Memory portion of an array — conflicts with PSH1019, which owns the array range-indexer rewrite and refuses it for mutable Span/Memory targets
dotnet_diagnostic.CA1834.severity = none # Use StringBuilder.Append(char) for single character strings — covered by PSH1202
dotnet_diagnostic.CA1835.severity = none # Prefer the memory-based overloads of ReadAsync/WriteAsync methods in stream-based classes — covered by PSH1314
dotnet_diagnostic.CA1836.severity = none # Prefer IsEmpty over Count when available — covered by PSH1117
dotnet_diagnostic.CA1837.severity = none # Use Environment.ProcessId — covered by PSH1405
dotnet_diagnostic.CA1838.severity = error # Avoid StringBuilder parameters for P/Invokes
dotnet_diagnostic.CA1839.severity = none # Use Environment.ProcessPath — covered by PSH1405
dotnet_diagnostic.CA1840.severity = none # Use Environment.CurrentManagedThreadId — covered by PSH1405
dotnet_diagnostic.CA1841.severity = none # Prefer Dictionary.Contains methods — covered by PSH1407
dotnet_diagnostic.CA1842.severity = none # Do not use 'WhenAll' with a single task — covered by PSH1301
dotnet_diagnostic.CA1843.severity = none # Do not use 'WaitAll' with a single task — covered by PSH1301
dotnet_diagnostic.CA1844.severity = error # Provide memory-based overrides of async methods when subclassing 'Stream'
dotnet_diagnostic.CA1845.severity = none # Use span-based 'string.Concat' — covered by PSH1222
dotnet_diagnostic.CA1846.severity = none # Prefer AsSpan over Substring — covered by PSH1212
dotnet_diagnostic.CA1847.severity = none # Covered by PSH1201 (canonical)
dotnet_diagnostic.CA1848.severity = error # Use the LoggerMessage delegates
dotnet_diagnostic.CA1849.severity = none # Call async methods when in an async method — covered by PSH1313
dotnet_diagnostic.CA1850.severity = none # Prefer static HashData method over ComputeHash — covered by PSH1400
dotnet_diagnostic.CA1851.severity = error # Possible multiple enumerations of IEnumerable collection
dotnet_diagnostic.CA1852.severity = none # Seal internal types — covered by PSH1411
dotnet_code_quality.CA1852.api_surface = private, internal # only flag non-public classes; public classes stay open for inheritance
dotnet_diagnostic.CA1853.severity = none # Unnecessary call to 'Dictionary.ContainsKey(key)' — covered by PSH1105
dotnet_diagnostic.CA1854.severity = none # Prefer the IDictionary.TryGetValue method — covered by PSH1104
dotnet_diagnostic.CA1855.severity = error # Prefer 'Clear' over 'Fill'
dotnet_diagnostic.CA1856.severity = error # Incorrect usage of ConstantExpected attribute
dotnet_diagnostic.CA1857.severity = error # A constant is expected for the parameter
dotnet_diagnostic.CA1858.severity = none # Use 'StartsWith' instead of 'IndexOf' — covered by PSH1221
dotnet_diagnostic.CA1859.severity = error # Use concrete types when possible for improved performance
dotnet_diagnostic.CA1860.severity = none # Avoid using 'Enumerable.Any()' extension method — covered by PSH1103
dotnet_diagnostic.CA1861.severity = none # Avoid constant arrays as arguments — covered by PSH1004
dotnet_diagnostic.CA1862.severity = none # Use the 'StringComparison' overloads for case-insensitive comparisons — covered by PSH1200
dotnet_diagnostic.CA1863.severity = none # Use 'CompositeFormat' — covered by PSH1223
dotnet_diagnostic.CA1864.severity = none # Prefer the 'IDictionary.TryAdd' method — covered by PSH1115
dotnet_diagnostic.CA1865.severity = none # Covered by PSH1201 (canonical)
dotnet_diagnostic.CA1866.severity = none # Covered by PSH1201 (canonical)
dotnet_diagnostic.CA1867.severity = none # Covered by PSH1201 (canonical)
dotnet_diagnostic.CA1868.severity = none # Unnecessary call to 'Contains' for sets — covered by PSH1105
dotnet_diagnostic.CA1869.severity = none # Cache and reuse 'JsonSerializerOptions' instances — covered by PSH1416
dotnet_diagnostic.CA1870.severity = none # Use a cached 'SearchValues' instance — covered by PSH1213
dotnet_diagnostic.CA1871.severity = error # Do not pass a nullable struct to 'ArgumentNullException.ThrowIfNull'
dotnet_diagnostic.CA1872.severity = none # Prefer 'Convert.ToHexString' and 'Convert.ToHexStringLower' over call chains based on 'BitConverter.ToString' — covered by PSH1224
dotnet_diagnostic.CA1873.severity = none # Avoid potentially expensive evaluation of arguments to 'Debug.Assert' — covered by PSH1417
dotnet_diagnostic.CA1874.severity = none # Use 'Regex.IsMatch' — covered by PSH1406
dotnet_diagnostic.CA1875.severity = none # Use 'Regex.Count' — covered by PSH1406
dotnet_diagnostic.CA1877.severity = none # Use 'Encoding.GetString' instead of 'Encoding.GetChars' — covered by PSH1225

# Reliability
dotnet_diagnostic.CA2000.severity = suggestion # Dispose objects before losing scope
dotnet_diagnostic.CA2002.severity = error # Do not lock on objects with weak identity
dotnet_diagnostic.CA2007.severity = none # Do not directly await a Task — Rx and library callers drive synchronization context themselves
dotnet_diagnostic.CA2008.severity = error # Do not create tasks without passing a TaskScheduler
dotnet_diagnostic.CA2009.severity = error # Do not call ToImmutableCollection on an ImmutableCollection value
dotnet_diagnostic.CA2011.severity = error # Do not assign property within its setter
dotnet_diagnostic.CA2012.severity = error # Use ValueTasks correctly
dotnet_diagnostic.CA2013.severity = error # Do not use ReferenceEquals with value types
dotnet_diagnostic.CA2014.severity = error # Do not use stackalloc in loops
dotnet_diagnostic.CA2015.severity = error # Do not define finalizers for types derived from MemoryManager<T>
dotnet_diagnostic.CA2016.severity = error # Forward the CancellationToken parameter to methods that take one
dotnet_diagnostic.CA2017.severity = error # Parameter count mismatch
dotnet_diagnostic.CA2018.severity = error # The 'count' argument to 'Buffer.BlockCopy' should specify the number of bytes to copy
dotnet_diagnostic.CA2019.severity = error # Improper 'ThreadStatic' field initialization
dotnet_diagnostic.CA2020.severity = error # Prevent behavioral change caused by built-in operators of IntPtr/UIntPtr
dotnet_diagnostic.CA2021.severity = error # Don't call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types
dotnet_diagnostic.CA2022.severity = error # Avoid inexact read with 'Stream.Read'
dotnet_diagnostic.CA2023.severity = error # Invalid braces in message template
dotnet_diagnostic.CA2024.severity = error # Do not use 'StreamReader.EndOfStream' in async methods
dotnet_diagnostic.CA2025.severity = error # Do not pass 'IDisposable' instances into unawaited tasks
dotnet_diagnostic.CA2026.severity = error # Do not use methods or types annotated with [RequiresDynamicCode] in code that uses [RequiresDynamicCode]

# Usage
dotnet_diagnostic.CA1801.severity = error # Review unused parameters
dotnet_code_quality.CA1801.api_surface = private, internal # only flag non-public APIs so we don't break public signatures
dotnet_diagnostic.CA1816.severity = error # Call GC.SuppressFinalize correctly
dotnet_diagnostic.CA2200.severity = none # Rethrow to preserve stack details — covered by SST1430
dotnet_diagnostic.CA2201.severity = error # Do not raise reserved exception types
dotnet_diagnostic.CA2207.severity = error # Initialize value type static fields inline
dotnet_diagnostic.CA2208.severity = none # Instantiate argument exceptions correctly — too sensitive: flags valid context-forwarding nameof(arg.Property) patterns
dotnet_diagnostic.CA2211.severity = none # Non-constant fields should not be visible — covered by SST1499
dotnet_diagnostic.CA2213.severity = error # Disposable fields should be disposed
dotnet_diagnostic.CA2214.severity = none # Do not call overridable methods in constructors — covered by SST1483
dotnet_diagnostic.CA2215.severity = error # Dispose methods should call base class dispose
dotnet_diagnostic.CA2216.severity = none # Disposable types should declare finalizer — conflicts with SST2317, which owns the owned-native-handle shape and prescribes a SafeHandle instead of a finalizer
dotnet_diagnostic.CA2217.severity = none # Do not mark enums with FlagsAttribute — covered by SST2303
dotnet_diagnostic.CA2218.severity = error # Override GetHashCode on overriding Equals
dotnet_diagnostic.CA2219.severity = error # Do not raise exceptions in finally clauses
dotnet_diagnostic.CA2224.severity = none # Override Equals on overloading operator equals — covered by SST2302
dotnet_diagnostic.CA2225.severity = error # Operator overloads have named alternates
dotnet_diagnostic.CA2226.severity = error # Operators should have symmetrical overloads
dotnet_diagnostic.CA2227.severity = none # Collection properties should be read only — settable collection properties are common in our DTOs and config types
dotnet_diagnostic.CA2231.severity = error # Overload operator equals on overriding ValueType.Equals
dotnet_diagnostic.CA2234.severity = error # Pass System.Uri objects instead of strings
dotnet_diagnostic.CA2241.severity = error # Provide correct arguments to formatting methods
dotnet_diagnostic.CA2242.severity = none # Test for NaN correctly — covered by SST1473
dotnet_diagnostic.CA2243.severity = error # Attribute string literals should parse correctly
dotnet_diagnostic.CA2244.severity = error # Do not duplicate indexed element initializations
dotnet_diagnostic.CA2245.severity = none # Do not assign a property to itself — covered by SST1189
dotnet_diagnostic.CA2246.severity = error # Do not assign a symbol and its member in the same statement
dotnet_diagnostic.CA2247.severity = error # Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum
dotnet_diagnostic.CA2248.severity = error # Provide correct enum argument to Enum.HasFlag
dotnet_diagnostic.CA2249.severity = error # Use String.Contains instead of String.IndexOf for substring checks
dotnet_diagnostic.CA2250.severity = error # Use ThrowIfCancellationRequested
dotnet_diagnostic.CA2251.severity = none # Covered by PSH1216 (canonical)
dotnet_diagnostic.CA2252.severity = error # Opt in to preview features before using them
dotnet_diagnostic.CA2253.severity = error # Named placeholders should not be numeric values
dotnet_diagnostic.CA2254.severity = error # Template should be a static expression
dotnet_diagnostic.CA2255.severity = error # The 'ModuleInitializer' attribute should not be used in libraries
dotnet_diagnostic.CA2256.severity = error # All members declared in parent interfaces must have an implementation in a 'DynamicInterfaceCastableImplementation' interface
dotnet_diagnostic.CA2257.severity = error # Members defined in a type with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static'
dotnet_diagnostic.CA2258.severity = error # Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported
dotnet_diagnostic.CA2259.severity = error # 'ThreadStatic' only affects static fields
dotnet_diagnostic.CA2260.severity = error # Implement generic math interfaces correctly
dotnet_diagnostic.CA2261.severity = error # Do not use 'ConfigureAwaitOptions.SuppressThrowing' with 'Task<TResult>'
dotnet_diagnostic.CA2262.severity = error # Set 'MaxResponseHeadersLength' properly
dotnet_diagnostic.CA2263.severity = error # Prefer generic overload when type is known
dotnet_diagnostic.CA2264.severity = error # Do not pass a non-nullable value to 'ArgumentNullException.ThrowIfNull'
dotnet_diagnostic.CA2265.severity = error # Do not compare Span<T> to 'null' or 'default'
dotnet_diagnostic.CA2266.severity = error # Do not consume the result of 'Span<T>.Enumerator.MoveNext()' more than once
dotnet_diagnostic.CA2267.severity = error # Member should not be marked with 'StaticAttribute'
dotnet_diagnostic.CA2268.severity = error # Use 'string.Equals(string, string, StringComparison)' instead of the implicit ordinal overload
# Skipped (deprecated ISerializable formatter): CA2229 Implement serialization constructors,
# CA2235 Mark all non-serializable fields, CA2237 Mark ISerializable types with SerializableAttribute.

# Security

# SQL Injection & Command Injection
dotnet_diagnostic.CA2100.severity = error # Review SQL queries for security vulnerabilities
dotnet_diagnostic.CA3001.severity = error # Review code for SQL injection vulnerabilities
dotnet_diagnostic.CA3006.severity = error # Review code for process command injection vulnerabilities

# Cross-Site Scripting (XSS) & Injection Attacks
dotnet_diagnostic.CA3002.severity = error # Review code for XSS vulnerabilities
dotnet_diagnostic.CA3003.severity = error # Review code for file path injection vulnerabilities
dotnet_diagnostic.CA3005.severity = error # Review code for LDAP injection vulnerabilities
dotnet_diagnostic.CA3007.severity = error # Review code for open redirect vulnerabilities
dotnet_diagnostic.CA3008.severity = error # Review code for XPath injection vulnerabilities
dotnet_diagnostic.CA3009.severity = error # Review code for XML injection vulnerabilities
dotnet_diagnostic.CA3010.severity = error # Review code for XAML injection vulnerabilities
dotnet_diagnostic.CA3011.severity = error # Review code for DLL injection vulnerabilities
dotnet_diagnostic.CA3012.severity = error # Review code for regex injection vulnerabilities
dotnet_diagnostic.CA3004.severity = error # Review code for information disclosure vulnerabilities

# Insecure Deserialization
dotnet_diagnostic.CA2300.severity = error # Do not use insecure deserializer BinaryFormatter
dotnet_diagnostic.CA2301.severity = error # Do not call BinaryFormatter.Deserialize without setting Binder
dotnet_diagnostic.CA2302.severity = error # Ensure BinaryFormatter.Binder is set before deserializing
dotnet_diagnostic.CA2305.severity = error # Do not use insecure deserializer LosFormatter
dotnet_diagnostic.CA2310.severity = error # Do not use insecure deserializer NetDataContractSerializer
dotnet_diagnostic.CA2311.severity = error # Do not deserialize without setting NetDataContractSerializer.Binder
dotnet_diagnostic.CA2312.severity = error # Ensure NetDataContractSerializer.Binder is set before deserializing
dotnet_diagnostic.CA2315.severity = error # Do not use insecure deserializer ObjectStateFormatter
dotnet_diagnostic.CA2321.severity = error # Do not deserialize with JavaScriptSerializer using SimpleTypeResolver
dotnet_diagnostic.CA2322.severity = error # Ensure JavaScriptSerializer not initialized with SimpleTypeResolver
dotnet_diagnostic.CA2326.severity = error # Do not use TypeNameHandling values other than None
dotnet_diagnostic.CA2327.severity = error # Do not use insecure JsonSerializerSettings
dotnet_diagnostic.CA2328.severity = error # Ensure that JsonSerializerSettings are secure
dotnet_diagnostic.CA2329.severity = error # Do not deserialize with JsonSerializer using insecure configuration
dotnet_diagnostic.CA2330.severity = error # Ensure JsonSerializer has secure configuration when deserializing
dotnet_diagnostic.CA2350.severity = error # Ensure DataTable.ReadXml()'s input is trusted
dotnet_diagnostic.CA2351.severity = error # Ensure DataSet.ReadXml()'s input is trusted
dotnet_diagnostic.CA2352.severity = error # Unsafe DataSet/DataTable in serializable type vulnerable to RCE
dotnet_diagnostic.CA2353.severity = error # Unsafe DataSet or DataTable in serializable type
dotnet_diagnostic.CA2354.severity = error # Unsafe DataSet/DataTable in deserialized object graph vulnerable to RCE
dotnet_diagnostic.CA2355.severity = error # Unsafe DataSet or DataTable in deserialized object graph
dotnet_diagnostic.CA2356.severity = error # Unsafe DataSet/DataTable in web deserialized object graph
dotnet_diagnostic.CA2361.severity = error # Ensure autogenerated class with DataSet.ReadXml() not used with untrusted data
dotnet_diagnostic.CA2362.severity = error # Unsafe DataSet/DataTable in autogenerated serializable type vulnerable to RCE
dotnet_diagnostic.CA5360.severity = error # Do not call dangerous methods in deserialization
dotnet_diagnostic.CA5362.severity = error # Potential reference cycle in deserialized object graph

# Cryptography - Weak & Broken Algorithms
dotnet_diagnostic.CA5350.severity = error # Do not use weak cryptographic algorithms (SHA1, RIPEMD160, TripleDES)
dotnet_diagnostic.CA5351.severity = error # Do not use broken cryptographic algorithms (MD5, DES, RC2)
dotnet_diagnostic.CA5358.severity = error # Do not use unsafe cipher modes (ECB, OFB, CFB)
dotnet_diagnostic.CA5373.severity = error # Do not use obsolete key derivation function
dotnet_diagnostic.CA5379.severity = error # Ensure key derivation function algorithm is sufficiently strong
dotnet_diagnostic.CA5384.severity = error # Do not use Digital Signature Algorithm (DSA)
dotnet_diagnostic.CA5385.severity = error # Use RSA algorithm with sufficient key size (>= 2048 bits)
dotnet_diagnostic.CA5387.severity = error # Do not use weak key derivation function with insufficient iteration count
dotnet_diagnostic.CA5388.severity = error # Ensure sufficient iteration count when using weak key derivation function
dotnet_diagnostic.CA5390.severity = error # Do not hard-code encryption key
dotnet_diagnostic.CA5394.severity = error # Do not use insecure randomness (use RNGCryptoServiceProvider)
dotnet_diagnostic.CA5401.severity = error # Do not use CreateEncryptor with non-default IV
dotnet_diagnostic.CA5402.severity = error # Use CreateEncryptor with the default IV
dotnet_diagnostic.CA5403.severity = error # Do not hard-code certificate

# TLS/SSL Protocol Security
dotnet_diagnostic.CA5359.severity = error # Do not disable certificate validation
dotnet_diagnostic.CA5361.severity = error # Do not disable SChannel use of strong crypto
dotnet_diagnostic.CA5364.severity = error # Do not use deprecated security protocols (TLS 1.0, TLS 1.1, SSL3)
dotnet_diagnostic.CA5378.severity = error # Do not disable ServicePointManagerSecurityProtocols
dotnet_diagnostic.CA5380.severity = error # Do not add certificates to root store
dotnet_diagnostic.CA5381.severity = error # Ensure certificates are not added to root store
dotnet_diagnostic.CA5386.severity = error # Avoid hardcoding SecurityProtocolType value
dotnet_diagnostic.CA5397.severity = error # Do not use deprecated SslProtocols values
dotnet_diagnostic.CA5398.severity = error # Avoid hardcoded SslProtocols values
dotnet_diagnostic.CA5399.severity = error # Definitely disable HttpClient certificate revocation list check
dotnet_diagnostic.CA5400.severity = error # Ensure HttpClient certificate revocation list check is not disabled

# Azure Storage / Shared Access Signature
dotnet_diagnostic.CA5375.severity = error # Do not use account shared access signature
dotnet_diagnostic.CA5376.severity = error # Use SharedAccessProtocol HttpsOnly
dotnet_diagnostic.CA5377.severity = error # Use container level access policy

# XML Security
dotnet_diagnostic.CA3061.severity = error # Do not add schema by URL
dotnet_diagnostic.CA3075.severity = error # Insecure DTD processing
dotnet_diagnostic.CA3076.severity = error # Insecure XSLT script execution
dotnet_diagnostic.CA3077.severity = error # Insecure processing in API design, XML Document and XML Text Reader
dotnet_diagnostic.CA5366.severity = error # Use XmlReader for DataSet read XML
dotnet_diagnostic.CA5369.severity = error # Use XmlReader for deserialize
dotnet_diagnostic.CA5370.severity = error # Use XmlReader for validating reader
dotnet_diagnostic.CA5371.severity = error # Use XmlReader for schema read
dotnet_diagnostic.CA5372.severity = error # Use XmlReader for XPathDocument
dotnet_diagnostic.CA5374.severity = error # Do not use XslTransform

# Web Security
dotnet_diagnostic.CA3147.severity = error # Mark verb handlers with ValidateAntiForgeryToken
dotnet_diagnostic.CA5363.severity = error # Do not disable request validation
dotnet_diagnostic.CA5365.severity = error # Do not disable HTTP header checking
dotnet_diagnostic.CA5368.severity = error # Set ViewStateUserKey for classes derived from Page
dotnet_diagnostic.CA5382.severity = error # Use secure cookies in ASP.NET Core
dotnet_diagnostic.CA5383.severity = error # Ensure use of secure cookies in ASP.NET Core
dotnet_diagnostic.CA5391.severity = error # Use antiforgery tokens in ASP.NET Core MVC controllers
dotnet_diagnostic.CA5395.severity = error # Miss HttpVerb attribute for action methods
dotnet_diagnostic.CA5396.severity = error # Set HttpOnly to true for HttpCookie

# P/Invoke & DLL Security
dotnet_diagnostic.CA2101.severity = error # Specify marshalling for P/Invoke string arguments
dotnet_diagnostic.CA5392.severity = error # Use DefaultDllImportSearchPaths attribute for P/Invokes
dotnet_diagnostic.CA5393.severity = error # Do not use unsafe DllImportSearchPath value

# Archive & File Security
dotnet_diagnostic.CA5389.severity = error # Do not add archive item's path to target file system path (Zip Slip)

# Token Validation & Authentication
dotnet_diagnostic.CA5404.severity = error # Do not disable token validation checks
dotnet_diagnostic.CA5405.severity = error # Do not always skip token validation in delegates

# Other Security Rules
dotnet_diagnostic.CA2109.severity = error # Review visible event handlers
dotnet_diagnostic.CA2119.severity = error # Seal methods that satisfy private interfaces
dotnet_diagnostic.CA2153.severity = error # Do not catch corrupted state exceptions
dotnet_diagnostic.CA5367.severity = error # Do not serialize types with pointer fields

###################
# Microsoft .NET SDK Diagnostics (SYSLIB)
###################
# Runtime obsoletions
dotnet_diagnostic.SYSLIB0001.severity = error # The UTF-7 encoding is insecure and should not be used
dotnet_diagnostic.SYSLIB0002.severity = error # PrincipalPermissionAttribute is not honored by the runtime and must not be used
dotnet_diagnostic.SYSLIB0003.severity = error # Code Access Security (CAS) is not supported or honored by the runtime
dotnet_diagnostic.SYSLIB0004.severity = error # Constrained Execution Region (CER) feature is not supported
dotnet_diagnostic.SYSLIB0005.severity = error # Global Assembly Cache is not supported
dotnet_diagnostic.SYSLIB0006.severity = error # Thread.Abort is not supported and throws PlatformNotSupportedException
dotnet_diagnostic.SYSLIB0007.severity = error # The default implementation of this cryptography algorithm is not supported
dotnet_diagnostic.SYSLIB0008.severity = error # The CreatePdbGenerator API is not supported and throws PlatformNotSupportedException
dotnet_diagnostic.SYSLIB0009.severity = error # The AuthenticationManager Authenticate and PreAuthenticate methods are not supported
dotnet_diagnostic.SYSLIB0010.severity = error # This Remoting API is not supported and throws PlatformNotSupportedException
dotnet_diagnostic.SYSLIB0011.severity = error # BinaryFormatter serialization is obsolete
dotnet_diagnostic.SYSLIB0012.severity = error # Assembly.CodeBase and Assembly.EscapedCodeBase are obsolete
dotnet_diagnostic.SYSLIB0013.severity = error # Uri.EscapeUriString can corrupt the Uri string
dotnet_diagnostic.SYSLIB0014.severity = error # WebRequest, HttpWebRequest, ServicePoint, and WebClient are obsolete — use HttpClient
dotnet_diagnostic.SYSLIB0015.severity = error # DisablePrivateReflectionAttribute is not honored
dotnet_diagnostic.SYSLIB0016.severity = error # Use Marshal.GetExceptionPointers instead
dotnet_diagnostic.SYSLIB0017.severity = error # Strong name signing is not supported on .NET Core
dotnet_diagnostic.SYSLIB0018.severity = error # ReflectionOnly loading is not supported
dotnet_diagnostic.SYSLIB0019.severity = error # RuntimeEnvironment members SystemConfigurationFile, GetSystemVersion, and FromGlobalAccessCache are not supported
dotnet_diagnostic.SYSLIB0020.severity = error # JsonSerializerOptions.IgnoreNullValues is obsolete — use DefaultIgnoreCondition
dotnet_diagnostic.SYSLIB0021.severity = error # Derived cryptographic types are obsolete — use the Create factory methods
dotnet_diagnostic.SYSLIB0022.severity = error # Rijndael types are obsolete — use Aes
dotnet_diagnostic.SYSLIB0023.severity = error # RNGCryptoServiceProvider is obsolete — use RandomNumberGenerator
dotnet_diagnostic.SYSLIB0024.severity = error # Creating and unloading AppDomains is not supported and throws an exception
dotnet_diagnostic.SYSLIB0025.severity = error # SuppressIldasmAttribute has no effect in .NET 6.0+
dotnet_diagnostic.SYSLIB0026.severity = error # X509Certificate and X509Certificate2 parameterless constructors are obsolete
dotnet_diagnostic.SYSLIB0027.severity = error # PublicKey.Key is obsolete — use the appropriate method to get the public key
dotnet_diagnostic.SYSLIB0028.severity = error # X509Certificate2.PrivateKey is obsolete — use the appropriate method to get the private key
dotnet_diagnostic.SYSLIB0029.severity = error # ProduceLegacyHmacValues is obsolete
dotnet_diagnostic.SYSLIB0030.severity = error # HMACSHA1 always uses the algorithm implementation provided by the platform
dotnet_diagnostic.SYSLIB0031.severity = error # EncodingProvider.GetEncoding(int, EncoderFallback, DecoderFallback) is obsolete
dotnet_diagnostic.SYSLIB0032.severity = error # Recovery from corrupted process state exceptions is not supported
dotnet_diagnostic.SYSLIB0033.severity = error # Rfc2898DeriveBytes.CryptDeriveKey is obsolete
dotnet_diagnostic.SYSLIB0034.severity = error # CmsSigner has been deprecated — use a constructor that accepts a SubjectIdentifierType
dotnet_diagnostic.SYSLIB0035.severity = error # ComputeCounterSignature without specifying a CmsSigner is obsolete
dotnet_diagnostic.SYSLIB0036.severity = error # Regex.CompileToAssembly is obsolete and not supported — use the RegexGenerator source generator
dotnet_diagnostic.SYSLIB0037.severity = error # AssemblyName members HashAlgorithm, ProcessorArchitecture, and VersionCompatibility are obsolete
dotnet_diagnostic.SYSLIB0038.severity = error # SerializationFormat.Binary is obsolete
dotnet_diagnostic.SYSLIB0039.severity = error # TLS versions 1.0 and 1.1 have known vulnerabilities and are not recommended
dotnet_diagnostic.SYSLIB0040.severity = error # EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security
dotnet_diagnostic.SYSLIB0041.severity = error # The default iteration count for Rfc2898DeriveBytes parameters is outdated and insecure
dotnet_diagnostic.SYSLIB0042.severity = error # ToXmlString and FromXmlString have no implementation for ECC types
dotnet_diagnostic.SYSLIB0043.severity = error # ECDiffieHellmanPublicKey.ToByteArray() and the associated constructor do not have a consistent and interoperable implementation
dotnet_diagnostic.SYSLIB0044.severity = error # AssemblyName.CodeBase and AssemblyName.EscapedCodeBase are obsolete
dotnet_diagnostic.SYSLIB0045.severity = error # Cryptographic factory methods accepting an algorithm name are obsolete
dotnet_diagnostic.SYSLIB0046.severity = error # ControlledExecution.Run may corrupt the process and should not be used in production code
dotnet_diagnostic.SYSLIB0047.severity = error # XmlSecureResolver is obsolete
dotnet_diagnostic.SYSLIB0048.severity = error # RSA.EncryptValue and RSA.DecryptValue are not supported and throw NotSupportedException
dotnet_diagnostic.SYSLIB0049.severity = error # JsonSerializerOptions.AddContext is obsolete
dotnet_diagnostic.SYSLIB0050.severity = error # Formatter-based serialization (ISerializable, FormatterServices, etc.) is obsolete
dotnet_diagnostic.SYSLIB0051.severity = error # The Exception API ISerializable / GetObjectData formatter-based serialization is obsolete
dotnet_diagnostic.SYSLIB0052.severity = error # Members for assigning to AssemblyName.CodeBase or AssemblyName.EscapedCodeBase are obsolete
dotnet_diagnostic.SYSLIB0053.severity = error # AesGcm should indicate the required tag size for encryption and decryption
dotnet_diagnostic.SYSLIB0054.severity = error # Strong name signing is not supported and throws PlatformNotSupportedException
dotnet_diagnostic.SYSLIB0055.severity = error # 'Memory.Pin' may be incorrectly used with structures
dotnet_diagnostic.SYSLIB0056.severity = error # LoadFromHash and related members are obsolete
dotnet_diagnostic.SYSLIB0057.severity = error # Use X509CertificateLoader instead to load certificates
dotnet_diagnostic.SYSLIB0058.severity = error # KeyExchangeAlgorithm and KeyExchangeStrength are obsolete on SslStream
dotnet_diagnostic.SYSLIB0059.severity = error # SystemEvents.EventsThreadShutdown event is obsolete
dotnet_diagnostic.SYSLIB0060.severity = error # Constructors of DirectoryServices.ActiveDirectory.ConfigurationContext are obsolete
dotnet_diagnostic.SYSLIB0061.severity = error # CryptographyConfig.AddOID and AddAlgorithm methods are obsolete

# Source generators
# LoggerMessage source generator
dotnet_diagnostic.SYSLIB1001.severity = error # Logging method names cannot start with _
dotnet_diagnostic.SYSLIB1002.severity = error # Don't include log level parameters as templates in the logging message
dotnet_diagnostic.SYSLIB1003.severity = error # LoggerMessage attribute log level value must be defined
dotnet_diagnostic.SYSLIB1004.severity = error # Logging class cannot be in nested types
dotnet_diagnostic.SYSLIB1005.severity = error # Could not find a required type definition
dotnet_diagnostic.SYSLIB1006.severity = error # Multiple logging methods cannot use the same event ID within a class
dotnet_diagnostic.SYSLIB1007.severity = error # Logging methods must return void
dotnet_diagnostic.SYSLIB1008.severity = error # One of the arguments to a logging method must implement ILogger
dotnet_diagnostic.SYSLIB1009.severity = error # Logging methods must be static
dotnet_diagnostic.SYSLIB1010.severity = error # Logging methods must be partial
dotnet_diagnostic.SYSLIB1011.severity = error # Logging methods cannot be generic
dotnet_diagnostic.SYSLIB1012.severity = error # Logging methods must not have a body
dotnet_diagnostic.SYSLIB1013.severity = error # Missing logger argument to logging method
dotnet_diagnostic.SYSLIB1015.severity = error # Argument is not referenced from the logging message
dotnet_diagnostic.SYSLIB1016.severity = error # Logging methods cannot have a parameter named the same as one of the template parameters
dotnet_diagnostic.SYSLIB1017.severity = error # Logging methods cannot have more than one parameter of type LogLevel
dotnet_diagnostic.SYSLIB1018.severity = error # Logging method parameter doesn't appear in template
dotnet_diagnostic.SYSLIB1019.severity = error # Couldn't find a field of type ILogger
dotnet_diagnostic.SYSLIB1020.severity = error # Found multiple fields of type ILogger
dotnet_diagnostic.SYSLIB1021.severity = error # Cannot have multiple logging methods with the same name
dotnet_diagnostic.SYSLIB1022.severity = error # Logging methods cannot have multiple template parameters with the same name
dotnet_diagnostic.SYSLIB1023.severity = error # Generating more than 6 arguments is not supported
dotnet_diagnostic.SYSLIB1024.severity = error # Logging method template name conflicts with a method parameter name
dotnet_diagnostic.SYSLIB1025.severity = error # Multiple template parameters with the same name
# Skipped SYSLIB1014 (Reserved)

# System.Text.Json source generator
dotnet_diagnostic.SYSLIB1030.severity = error # JsonSourceGenerator did not generate serialization metadata for type
dotnet_diagnostic.SYSLIB1031.severity = error # Duplicate type registration in JsonSerializerContext
dotnet_diagnostic.SYSLIB1032.severity = error # JsonSerializerContext classes must be partial
dotnet_diagnostic.SYSLIB1033.severity = error # Serializable types must have at least one constructor
dotnet_diagnostic.SYSLIB1034.severity = error # Type uses an unsupported [JsonExtensionData] property
dotnet_diagnostic.SYSLIB1036.severity = error # Init-only properties are not supported in source generation
dotnet_diagnostic.SYSLIB1037.severity = error # Source generator does not support [JsonInclude] on inaccessible members
dotnet_diagnostic.SYSLIB1038.severity = error # JsonInclude on a non-public property is not supported
dotnet_diagnostic.SYSLIB1039.severity = error # Type with extension data of unsupported shape
dotnet_diagnostic.SYSLIB1040.severity = error # Type with cycles is not supported
dotnet_diagnostic.SYSLIB1041.severity = error # Duplicate type names registered with JsonSerializerContext
# Skipped SYSLIB1035 (Reserved)

# GeneratedRegex source generator
dotnet_diagnostic.SYSLIB1042.severity = error # Use 'GeneratedRegexAttribute' for static regex creation
dotnet_diagnostic.SYSLIB1043.severity = error # The regex pattern is not valid
dotnet_diagnostic.SYSLIB1044.severity = error # The regex source generator failed
dotnet_diagnostic.SYSLIB1045.severity = error # Convert to 'GeneratedRegexAttribute' for compile-time regex generation
dotnet_diagnostic.SYSLIB1046.severity = error # Could not find an applicable Regex constructor
dotnet_diagnostic.SYSLIB1047.severity = error # The regex options are not valid for source generation
dotnet_diagnostic.SYSLIB1048.severity = error # GeneratedRegex source generator encountered an unhandled error
dotnet_diagnostic.SYSLIB1049.severity = error # Multiple regex source generators conflict

# LibraryImport (P/Invoke) source generator
dotnet_diagnostic.SYSLIB1050.severity = error # Method should be marked 'LibraryImport' instead of 'DllImport'
dotnet_diagnostic.SYSLIB1051.severity = error # Specified type is not supported by source-generated P/Invokes
dotnet_diagnostic.SYSLIB1052.severity = error # Specified configuration is not supported by source-generated P/Invokes
dotnet_diagnostic.SYSLIB1053.severity = error # 'LibraryImportAttribute' requires unsafe code
dotnet_diagnostic.SYSLIB1054.severity = error # Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time
dotnet_diagnostic.SYSLIB1055.severity = error # Invalid 'CustomMarshallerAttribute' usage
dotnet_diagnostic.SYSLIB1056.severity = error # Specified marshaller type is invalid
dotnet_diagnostic.SYSLIB1057.severity = error # Marshaller type does not have the required shape
dotnet_diagnostic.SYSLIB1058.severity = error # Invalid 'NativeMarshallingAttribute' usage
dotnet_diagnostic.SYSLIB1059.severity = error # Marshaller type must be a closed generic type
dotnet_diagnostic.SYSLIB1060.severity = error # Specified native type is invalid
dotnet_diagnostic.SYSLIB1061.severity = error # Marshaller type has incompatible method signatures
dotnet_diagnostic.SYSLIB1062.severity = error # Project must be updated with '<AllowUnsafeBlocks>true</AllowUnsafeBlocks>'
dotnet_diagnostic.SYSLIB1063.severity = error # 'CustomMarshaller' types must have an 'in' or 'ref' first parameter
dotnet_diagnostic.SYSLIB1064.severity = error # Forwarder marshaller types should not have 'GenericPlaceholder'

# GeneratedComInterface / COM source generator
dotnet_diagnostic.SYSLIB1090.severity = error # Convert to 'GeneratedComInterface'
dotnet_diagnostic.SYSLIB1091.severity = error # Type is an invalid 'GeneratedComInterface' base interface
dotnet_diagnostic.SYSLIB1092.severity = error # 'GeneratedComInterface' must specify 'Guid'
dotnet_diagnostic.SYSLIB1093.severity = error # Method on 'GeneratedComInterface' has unsupported return type
dotnet_diagnostic.SYSLIB1094.severity = error # Method on 'GeneratedComInterface' has unsupported parameter
dotnet_diagnostic.SYSLIB1095.severity = error # Type implements 'GeneratedComInterface' but is not partial
dotnet_diagnostic.SYSLIB1096.severity = error # 'GeneratedComClassAttribute' must be applied to a partial type
dotnet_diagnostic.SYSLIB1097.severity = error # 'GeneratedComClassAttribute' type must implement at least one 'GeneratedComInterface'
dotnet_diagnostic.SYSLIB1098.severity = error # 'GeneratedComInterface' interface inheritance not supported

# Configuration binding source generator
dotnet_diagnostic.SYSLIB1100.severity = error # Configuration binding source generator: type is not supported
dotnet_diagnostic.SYSLIB1101.severity = error # Configuration binding source generator: property on type is not supported
dotnet_diagnostic.SYSLIB1102.severity = error # Configuration binding source generator: not enabled
dotnet_diagnostic.SYSLIB1103.severity = error # Configuration binding source generator: type lacks a parameterless constructor
dotnet_diagnostic.SYSLIB1104.severity = error # Configuration binding source generator: language version is too low

###################
# Microsoft .NET Code Style Analyzers (IDE)
###################
# Language rules
# EnforceCodeStyleInBuild=true (set in Directory.Build.props) promotes these
# IDE rules into `dotnet build` so they fire at compile time, not just in the
# IDE. We enable the ones that are unambiguous wins and skip the rules that
# conflict with an existing convention (SA1101, SA1200, SA1206, SA1400, SA1633,
# etc.) so we don't double-report.

# Bug catchers — always error.
dotnet_diagnostic.IDE0035.severity = none # Remove unreachable code — covered by SST1453
dotnet_diagnostic.IDE0043.severity = none # Format string contains invalid placeholder — covered by SST1454
dotnet_diagnostic.IDE0052.severity = none # Remove unread private member — covered by SST1441

# Simplification / cleanup.
dotnet_diagnostic.IDE0002.severity = none # Simplify member access — covered by SST1117
dotnet_diagnostic.IDE0004.severity = none # Remove unnecessary cast — covered by SST1175
dotnet_diagnostic.IDE0016.severity = none # Use throw expression — covered by SST2207
dotnet_diagnostic.IDE0019.severity = none # Use pattern matching to avoid 'as' followed by a 'null' check — covered by SST2005/SST2274
dotnet_diagnostic.IDE0028.severity = none # Use collection initializers — covered by SST1194
dotnet_diagnostic.IDE0031.severity = none # Use null propagation — covered by SST1196
dotnet_diagnostic.IDE0038.severity = none # Use pattern matching ('is' check without a cast) — covered by SST2007
dotnet_diagnostic.IDE0041.severity = none # Use 'is null' check — covered by SST1149/SST2231/SST2282
dotnet_diagnostic.IDE0042.severity = none # Deconstruct variable declaration — covered by SST2214
dotnet_diagnostic.IDE0044.severity = none # Add readonly modifier — covered by SST1424
dotnet_diagnostic.IDE0047.severity = none # Remove unnecessary parentheses — covered by SST1459
dotnet_diagnostic.IDE0049.severity = none # Use language keywords instead of framework type names for type references — covered by SST1121
dotnet_diagnostic.IDE0057.severity = none # Use range operator — covered by SST2204
dotnet_diagnostic.IDE0059.severity = none # Remove unnecessary value assignment — covered by SST2222
dotnet_diagnostic.IDE0064.severity = none # Make struct fields writable — flag readonly-but-mutable struct fields where intent diverges from declaration
dotnet_diagnostic.IDE0066.severity = none # Use switch expression — covered by SST2201
dotnet_diagnostic.IDE0075.severity = none # Simplify conditional expression — covered by SST1182
dotnet_diagnostic.IDE0078.severity = none # Use pattern matching — covered by SST2006/SST2231
dotnet_diagnostic.IDE0084.severity = none # Use pattern matching ('IsNot' operator)
dotnet_diagnostic.IDE0120.severity = none # Simplify LINQ expression — covered by PSH1100/PSH1101
dotnet_diagnostic.IDE0221.severity = none # Add explicit cast — covered by SST2226
dotnet_diagnostic.IDE0250.severity = none # Make struct 'readonly' — covered by PSH1014
dotnet_diagnostic.IDE0260.severity = none # Use pattern matching — covered by SST2006/SST2231

# Disabled — conflict with an existing SA/CA rule or project convention.
dotnet_diagnostic.IDE0007.severity = none # Use var — we don't force var in either direction
dotnet_diagnostic.IDE0008.severity = none # Use explicit type — we don't force var in either direction
dotnet_diagnostic.IDE0009.severity = none # Member access should be qualified — SA1101 = none
dotnet_diagnostic.IDE0021.severity = none # Use expression body for constructors — covered by SST2276 (opt-in)
dotnet_diagnostic.IDE0022.severity = none # Use expression body for methods — covered by SST2275
dotnet_diagnostic.IDE0023.severity = none # Use expression body for conversion operators — covered by SST2278 (opt-in)
dotnet_diagnostic.IDE0024.severity = none # Use expression body for operators — covered by SST2277 (opt-in)
dotnet_diagnostic.IDE0025.severity = none # Use expression body for properties — covered by SST2279
dotnet_diagnostic.IDE0026.severity = none # Use expression body for indexers — covered by SST2280
dotnet_diagnostic.IDE0048.severity = none # Add parentheses for clarity — preference not enforced
dotnet_diagnostic.IDE0055.severity = none # Formatting — StyleCop SA rules own formatting
dotnet_diagnostic.IDE0058.severity = none # Remove unnecessary expression value — covered by SST2221
dotnet_diagnostic.IDE0060.severity = none # Remove unused parameter — CA1801 handles (with api_surface config)
dotnet_diagnostic.IDE0061.severity = none # Use expression body for local function — covered by SST2281
dotnet_diagnostic.IDE0079.severity = none # Remove unnecessary suppression — can misfire on multi-TFM suppressions
dotnet_diagnostic.IDE0130.severity = none # Namespace does not match folder structure — we don't enforce strict mirror
dotnet_diagnostic.IDE0160.severity = none # Use block-scoped namespace — we use file-scoped (IDE0161)
dotnet_diagnostic.IDE0210.severity = none # Convert to top-level statements — we use Main style
dotnet_diagnostic.IDE0211.severity = none # Convert to 'Program.Main' style — we use Main style
dotnet_diagnostic.IDE0300.severity = none # Use collection expression for array — covered by SST2101
dotnet_diagnostic.IDE0306.severity = none # Use collection expression for new — covered by SST2101
dotnet_diagnostic.IDE0320.severity = none # Make anonymous function static — covered by PSH1000
dotnet_diagnostic.IDE0050.severity = none # Convert anonymous type to tuple — covered by SST2224
dotnet_diagnostic.IDE0310.severity = none # Convert lambda expression to method group — handled by RCS1207
dotnet_diagnostic.IDE0360.severity = none # Simplify property accessor — covered by SST2219
dotnet_diagnostic.IDE0370.severity = none # Remove unnecessary suppression (null-forgiving operator) — disabled for the same reason as RCS1249: multi-TFM nullability annotations can differ per platform

# Language and unnecessary code rules.
dotnet_diagnostic.IDE0001.severity = none # Simplify name
dotnet_diagnostic.IDE0003.severity = none # Name can be simplified
dotnet_diagnostic.IDE0005.severity = none # Remove unnecessary import
dotnet_diagnostic.IDE0010.severity = none # Add missing cases to switch statement
dotnet_diagnostic.IDE0011.severity = none # Add braces
dotnet_diagnostic.IDE0017.severity = none # Use object initializers
dotnet_diagnostic.IDE0018.severity = none # Inline variable declaration
dotnet_diagnostic.IDE0020.severity = none # Use pattern matching to avoid is check followed by a cast (with variable)
dotnet_diagnostic.IDE0027.severity = none # Use expression body for accessors
dotnet_diagnostic.IDE0029.severity = none # Null check can be simplified
dotnet_diagnostic.IDE0030.severity = none # Null check can be simplified
dotnet_diagnostic.IDE0032.severity = none # Use auto property
dotnet_diagnostic.IDE0033.severity = none # Use explicitly provided tuple name
dotnet_diagnostic.IDE0034.severity = none # Simplify default expression
dotnet_diagnostic.IDE0036.severity = none # Order modifiers
dotnet_diagnostic.IDE0037.severity = none # Use inferred member name
dotnet_diagnostic.IDE0039.severity = none # Use local function instead of lambda
dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
dotnet_diagnostic.IDE0045.severity = none # Use conditional expression for assignment
dotnet_diagnostic.IDE0046.severity = none # Use conditional expression for return
dotnet_diagnostic.IDE0051.severity = none # Remove unused private member
dotnet_diagnostic.IDE0053.severity = none # Use expression body for lambdas
dotnet_diagnostic.IDE0054.severity = none # Use compound assignment
dotnet_diagnostic.IDE0056.severity = none # Use index operator
dotnet_diagnostic.IDE0062.severity = none # Make local function static
dotnet_diagnostic.IDE0063.severity = none # Use simple using statement
dotnet_diagnostic.IDE0065.severity = none # Using directive placement
dotnet_diagnostic.IDE0070.severity = none # Use System.HashCode.Combine
dotnet_diagnostic.IDE0071.severity = none # Simplify interpolation
dotnet_diagnostic.IDE0072.severity = none # Add missing cases to switch expression
dotnet_diagnostic.IDE0073.severity = none # Use file header
dotnet_diagnostic.IDE0074.severity = none # Use coalesce compound assignment
dotnet_diagnostic.IDE0076.severity = none # Remove invalid global SuppressMessageAttribute
dotnet_diagnostic.IDE0077.severity = none # Avoid legacy format target in global SuppressMessageAttribute
dotnet_diagnostic.IDE0080.severity = none # Remove unnecessary suppression operator
dotnet_diagnostic.IDE0082.severity = none # Convert typeof to nameof
dotnet_diagnostic.IDE0083.severity = none # Use pattern matching (not operator)
dotnet_diagnostic.IDE0090.severity = none # Simplify new expression
dotnet_diagnostic.IDE0100.severity = none # Remove unnecessary equality operator
dotnet_diagnostic.IDE0110.severity = none # Remove unnecessary discard
dotnet_diagnostic.IDE0150.severity = none # Prefer null check over type check
dotnet_diagnostic.IDE0161.severity = none # Use file-scoped namespace
dotnet_diagnostic.IDE0170.severity = none # Simplify property pattern
dotnet_diagnostic.IDE0180.severity = none # Use tuple to swap values
dotnet_diagnostic.IDE0200.severity = none # Remove unnecessary lambda expression
dotnet_diagnostic.IDE0220.severity = none # Add explicit cast in foreach loop
dotnet_diagnostic.IDE0230.severity = none # Use UTF-8 string literal
dotnet_diagnostic.IDE0240.severity = none # Nullable directive is redundant
dotnet_diagnostic.IDE0241.severity = none # Nullable directive is unnecessary
dotnet_diagnostic.IDE0251.severity = none # Member can be made readonly
dotnet_diagnostic.IDE0270.severity = none # Null check can be simplified
dotnet_diagnostic.IDE0280.severity = none # Use nameof
dotnet_diagnostic.IDE0290.severity = none # Use primary constructor
dotnet_diagnostic.IDE0301.severity = none # Use collection expression for empty
dotnet_diagnostic.IDE0302.severity = none # Use collection expression for stackalloc
dotnet_diagnostic.IDE0303.severity = none # Use collection expression for Create()
dotnet_diagnostic.IDE0304.severity = none # Use collection expression for builder
dotnet_diagnostic.IDE0305.severity = none # Use collection expression for fluent
dotnet_diagnostic.IDE0340.severity = none # Use unbound generic type
dotnet_diagnostic.IDE0350.severity = none # Use implicitly typed lambda
dotnet_diagnostic.IDE0380.severity = none # Remove unnecessary unsafe modifier
dotnet_diagnostic.IDE1005.severity = none # Use conditional delegate call

# Naming and miscellaneous
# Naming conventions — SA1300 family already enforces PascalCase / interface
# prefix / field casing (with our _underscore convention on SA1306/1309/1311
# deliberately disabled). Leaving IDE1006 off because configuring
# `dotnet_naming_rule.*` would duplicate what SA already enforces and could
# conflict with the _underscore convention.
dotnet_diagnostic.IDE1006.severity = none # Naming rule violation — SA1300 family handles naming
dotnet_diagnostic.IDE3000.severity = none # Disabled per project convention — not enforced

###################
# Roslynator.CSharp.Analyzers (RCS)
###################
# Code simplification
dotnet_diagnostic.RCS1001.severity = none # Add braces (when expression spans over multiple lines) — covered by SST1519
dotnet_diagnostic.RCS1003.severity = none # Add braces to if-else (when expression spans over multiple lines) — covered by SST1519
dotnet_diagnostic.RCS1005.severity = error # Simplify nested using statement
dotnet_diagnostic.RCS1006.severity = none # Merge 'else' with nested 'if' — covered by SST1465
dotnet_diagnostic.RCS1007.severity = error # Add braces
dotnet_diagnostic.RCS1031.severity = none # Remove unnecessary braces in switch section -- we don't mind braces in switch statements
dotnet_diagnostic.RCS1032.severity = error # Remove redundant parentheses
dotnet_diagnostic.RCS1033.severity = none # Remove redundant boolean literal — covered by SST1143
dotnet_diagnostic.RCS1039.severity = none # Remove argument list from attribute — covered by SST1411
dotnet_diagnostic.RCS1040.severity = none # Remove empty statement — covered by SST1180
dotnet_diagnostic.RCS1042.severity = none # Remove enum default underlying type — covered by SST1177
dotnet_diagnostic.RCS1043.severity = error # Remove 'partial' modifier from type with a single part
dotnet_diagnostic.RCS1049.severity = none # Simplify boolean comparison — covered by SST1143
dotnet_diagnostic.RCS1058.severity = none # Use compound assignment — covered by SST1185
dotnet_diagnostic.RCS1061.severity = none # Merge 'if' with nested 'if' — covered by SST2013
dotnet_diagnostic.RCS1068.severity = none # Simplify logical negation — covered by SST1172/SST2006
dotnet_diagnostic.RCS1069.severity = none # Remove unnecessary case label — covered by SST1466
dotnet_diagnostic.RCS1070.severity = none # Remove redundant default switch section — covered by SST1179
dotnet_diagnostic.RCS1071.severity = none # Remove redundant base constructor call — covered by SST1178
dotnet_diagnostic.RCS1072.severity = none # Remove empty namespace declaration — covered by SST1435
dotnet_diagnostic.RCS1073.severity = none # Convert 'if' to 'return' statement — covered by SST1197
dotnet_diagnostic.RCS1074.severity = none # Remove redundant constructor — covered by SST1433
dotnet_diagnostic.RCS1078.severity = none # Use "" or 'string.Empty' — conflicts with SST1122, which owns the string.Empty direction
dotnet_diagnostic.RCS1084.severity = none # Use coalesce expression instead of conditional expression — covered by SST1195
dotnet_diagnostic.RCS1085.severity = none # Use auto-implemented property — covered by SST1420
dotnet_diagnostic.RCS1089.severity = error # Use --/++ operator instead of assignment
dotnet_diagnostic.RCS1097.severity = error # Remove redundant 'ToString' call
dotnet_diagnostic.RCS1103.severity = error # Convert 'if' to assignment
dotnet_diagnostic.RCS1104.severity = none # Simplify conditional expression — covered by SST1182
dotnet_diagnostic.RCS1105.severity = error # Unnecessary interpolation
dotnet_diagnostic.RCS1106.severity = none # Remove empty destructor — covered by PSH1002
dotnet_diagnostic.RCS1107.severity = none # Remove redundant 'ToCharArray' call — covered by PSH1217
dotnet_diagnostic.RCS1114.severity = error # Remove redundant delegate creation
dotnet_diagnostic.RCS1124.severity = error # Inline local variable
dotnet_diagnostic.RCS1126.severity = error # Add braces to if-else
dotnet_diagnostic.RCS1128.severity = error # Use coalesce expression
dotnet_diagnostic.RCS1129.severity = none # Remove redundant field initialization — covered by SST1176
dotnet_diagnostic.RCS1132.severity = none # Remove redundant overriding member — covered by SST1181
dotnet_diagnostic.RCS1133.severity = error # Remove redundant Dispose/Close call
dotnet_diagnostic.RCS1134.severity = none # Remove redundant statement — covered by SST1174
dotnet_diagnostic.RCS1143.severity = error # Simplify coalesce expression
dotnet_diagnostic.RCS1145.severity = error # Remove redundant 'as' operator
dotnet_diagnostic.RCS1146.severity = error # Use conditional access
dotnet_diagnostic.RCS1151.severity = none # Remove redundant cast — covered by SST1175
dotnet_diagnostic.RCS1171.severity = error # Simplify lazy initialization
dotnet_diagnostic.RCS1173.severity = error # Use coalesce expression instead of 'if'
dotnet_diagnostic.RCS1174.severity = none # Remove redundant async/await — covered by PSH1311
dotnet_diagnostic.RCS1179.severity = error # Unnecessary assignment
dotnet_diagnostic.RCS1180.severity = error # Inline lazy initialization
dotnet_diagnostic.RCS1188.severity = none # Remove redundant auto-property initialization — covered by SST1176
dotnet_diagnostic.RCS1192.severity = none # Unnecessary usage of verbatim string literal — covered by SST1184
dotnet_diagnostic.RCS1199.severity = error # Unnecessary null check
dotnet_diagnostic.RCS1206.severity = error # Use conditional access instead of conditional expression
dotnet_diagnostic.RCS1207.severity = none # Use anonymous function or method group — conflicts with SST2239, which owns the method-group direction
dotnet_diagnostic.RCS1211.severity = none # Remove unnecessary 'else' — covered by SST1464
dotnet_diagnostic.RCS1212.severity = error # Remove redundant assignment
dotnet_diagnostic.RCS1214.severity = none # Unnecessary interpolated string — covered by SST1183
dotnet_diagnostic.RCS1216.severity = error # Unnecessary unsafe context
dotnet_diagnostic.RCS1217.severity = none # Convert interpolated string to concatenation — reverses SST2249, which owns the concatenation-to-interpolation direction
dotnet_diagnostic.RCS1218.severity = error # Simplify code branching
dotnet_diagnostic.RCS1220.severity = none # Use pattern matching instead of combination of 'is' and cast — covered by SST2007
dotnet_diagnostic.RCS1221.severity = error # Use pattern matching instead of combination of 'as' and null check
dotnet_diagnostic.RCS1238.severity = none # Avoid nested ?: operators — covered by SST1147
dotnet_diagnostic.RCS1244.severity = none # Simplify 'default' expression — covered by SST1188
dotnet_diagnostic.RCS1249.severity = none # Unnecessary null-forgiving operator — disabled because multi-TFM nullability annotations can differ per platform, leading to false positives
dotnet_diagnostic.RCS1251.severity = error # Remove unnecessary braces from record declaration
dotnet_diagnostic.RCS1259.severity = error # Remove empty syntax (replaces RCS1066)
dotnet_diagnostic.RCS1262.severity = error # Unnecessary raw string literal
dotnet_diagnostic.RCS1265.severity = none # Remove redundant catch block — covered by SST1470
dotnet_diagnostic.RCS1268.severity = error # Simplify numeric comparison

# Code quality
dotnet_diagnostic.RCS1013.severity = none # Use predefined type — covered by SST1121
dotnet_diagnostic.RCS1014.severity = error # Use explicitly/implicitly typed array
dotnet_diagnostic.RCS1015.severity = error # Use nameof operator
dotnet_diagnostic.RCS1016.severity = none # Use block body or expression body — conflicts with SST2219, which owns the expression-bodied accessor direction
dotnet_diagnostic.RCS1020.severity = none # Covered by SST2234 (canonical)
dotnet_diagnostic.RCS1021.severity = error # Convert lambda expression body to expression body
dotnet_diagnostic.RCS1044.severity = none # Remove original exception from throw statement — covered by SST1430
dotnet_diagnostic.RCS1046.severity = none # Asynchronous method name should end with 'Async' — TUnit test method naming convention doesn't follow the Async suffix — covered by SST1317
dotnet_diagnostic.RCS1047.severity = error # Non-asynchronous method name should not end with 'Async'
dotnet_diagnostic.RCS1048.severity = none # Use lambda expression instead of anonymous method — covered by SST1130
dotnet_diagnostic.RCS1050.severity = error # Include/omit parentheses when creating new object
dotnet_diagnostic.RCS1051.severity = none # Add/remove parentheses from condition in conditional operator — conflicts with SST1459, which owns the non-grouping-parenthesis removal direction
dotnet_diagnostic.RCS1056.severity = none # Avoid usage of using alias directive - used to avoid conflicts
dotnet_diagnostic.RCS1059.severity = none # Avoid locking on publicly accessible instance — covered by SST1901
dotnet_diagnostic.RCS1075.severity = none # Avoid empty catch clause that catches System.Exception — covered by SST1429
dotnet_diagnostic.RCS1079.severity = error # Throwing of new NotImplementedException
dotnet_diagnostic.RCS1081.severity = error # Split variable declaration
dotnet_diagnostic.RCS1093.severity = error # File contains no code
dotnet_diagnostic.RCS1094.severity = none # Declare using directive on top level — covered by SST1200
dotnet_diagnostic.RCS1096.severity = none # Use 'HasFlag' method or bitwise operator — covered by PSH1016
dotnet_diagnostic.RCS1098.severity = none # Constant values should be placed on right side of comparisons — covered by SST1186
dotnet_diagnostic.RCS1099.severity = none # Default label should be the last label in a switch section — covered by SST1466
dotnet_diagnostic.RCS1102.severity = none # Make class static — covered by SST1432
dotnet_diagnostic.RCS1108.severity = error # Add 'static' modifier to all partial class declarations
dotnet_diagnostic.RCS1111.severity = error # Add braces to switch section with multiple statements
dotnet_diagnostic.RCS1113.severity = error # Use 'string.IsNullOrEmpty' method
dotnet_diagnostic.RCS1118.severity = none # Mark local variable as const — covered by PSH1402
dotnet_diagnostic.RCS1123.severity = none # Add parentheses when necessary — covered by SST1407
dotnet_diagnostic.RCS1130.severity = none # Bitwise operation on enum without Flags attribute — covered by SST2458
dotnet_diagnostic.RCS1135.severity = error # Declare enum member with zero value (when enum has FlagsAttribute)
dotnet_diagnostic.RCS1136.severity = none # Merge switch sections with equivalent content — covered by SST2414
dotnet_diagnostic.RCS1154.severity = error # Sort enum members
dotnet_diagnostic.RCS1155.severity = none # Use StringComparison when comparing strings — covered by PSH1207
dotnet_diagnostic.RCS1156.severity = none # Use string.Length instead of comparison with empty string — covered by PSH1204
dotnet_diagnostic.RCS1157.severity = none # Composite enum value contains undefined flag — covered by SST2303
dotnet_diagnostic.RCS1159.severity = error # Use EventHandler<T>
dotnet_diagnostic.RCS1160.severity = none # Abstract type should not have public constructors — covered by SST1428
dotnet_diagnostic.RCS1161.severity = none # Enum should declare explicit values - do not need explicit values
dotnet_diagnostic.RCS1162.severity = none # Avoid chain of assignments — covered by SST1187
dotnet_diagnostic.RCS1166.severity = none # Value type object is never equal to null — covered by SST1469
dotnet_diagnostic.RCS1168.severity = none # Parameter name differs from base name — covered by SST1318
dotnet_diagnostic.RCS1169.severity = error # Make field read-only
dotnet_diagnostic.RCS1170.severity = error # Use read-only auto-implemented property
dotnet_diagnostic.RCS1172.severity = none # Use 'is' operator instead of 'as' operator — covered by SST2005
dotnet_diagnostic.RCS1187.severity = none # Use constant instead of field — covered by PSH1402
dotnet_diagnostic.RCS1191.severity = error # Declare enum value as combination of names
dotnet_diagnostic.RCS1193.severity = none # Overriding member should not change 'params' modifier — covered by SST2426
dotnet_diagnostic.RCS1196.severity = error # Call extension method as instance method
dotnet_diagnostic.RCS1200.severity = none # Call 'Enumerable.ThenBy' instead of 'Enumerable.OrderBy' — covered by PSH1108
dotnet_diagnostic.RCS1201.severity = error # Use method chaining
dotnet_diagnostic.RCS1202.severity = error # Avoid NullReferenceException
dotnet_diagnostic.RCS1204.severity = error # Use EventArgs.Empty
dotnet_diagnostic.RCS1205.severity = error # Order named arguments according to the order of parameters
dotnet_diagnostic.RCS1208.severity = error # Reduce 'if' nesting
dotnet_diagnostic.RCS1209.severity = error # Order type parameter constraints
dotnet_diagnostic.RCS1210.severity = none # Return completed task instead of returning null — covered by PSH1312
dotnet_diagnostic.RCS1215.severity = error # Expression is always equal to true/false
dotnet_diagnostic.RCS1222.severity = error # Merge preprocessor directives
dotnet_diagnostic.RCS1223.severity = suggestion # Mark publicly visible type with DebuggerDisplay attribute — only data types benefit; the rule is too broad to be an error
dotnet_diagnostic.RCS1224.severity = error # Make method an extension method
dotnet_diagnostic.RCS1225.severity = error # Make class sealed
dotnet_diagnostic.RCS1227.severity = none # Validate arguments correctly — covered by SST2404
dotnet_diagnostic.RCS1229.severity = error # Use async/await when necessary
dotnet_diagnostic.RCS1231.severity = none # Make parameter ref read-only — covered by PSH1007
dotnet_diagnostic.RCS1233.severity = none # Use short-circuiting operator — covered by SST1468
dotnet_diagnostic.RCS1234.severity = error # Duplicate enum value
dotnet_diagnostic.RCS1239.severity = error # Use 'for' statement instead of 'while' statement
dotnet_diagnostic.RCS1240.severity = error # Operator is unnecessary
dotnet_diagnostic.RCS1242.severity = none # Do not pass non-read-only struct by read-only reference — covered by PSH1003
dotnet_diagnostic.RCS1243.severity = none # Duplicate word in a comment — covered by SST1658 (documentation comments)
dotnet_diagnostic.RCS1247.severity = error # Fix documentation comment tag
dotnet_diagnostic.RCS1248.severity = none # Normalize null check — conflicts with SST1149, which owns the 'is null' pattern direction
dotnet_diagnostic.RCS1250.severity = none # Use implicit/explicit object creation — conflicts with SST2202, which owns the implicit-target-type direction
dotnet_diagnostic.RCS1252.severity = error # Normalize usage of infinite loop
dotnet_diagnostic.RCS1254.severity = error # Normalize format of enum flag value
dotnet_diagnostic.RCS1255.severity = none # Simplify argument null check — conflicts with our ArgumentExceptionHelper helper pattern
dotnet_diagnostic.RCS1257.severity = error # Use enum field explicitly
dotnet_diagnostic.RCS1258.severity = error # Unnecessary enum flag
dotnet_diagnostic.RCS1260.severity = none # Add/remove trailing comma — conflicts with SST1413, which owns the trailing-comma direction
dotnet_diagnostic.RCS1261.severity = none # Resource can be disposed asynchronously — covered by PSH1310
dotnet_diagnostic.RCS1264.severity = error # Use 'var' or explicit type (replaces RCS1010, RCS1176, RCS1177)
dotnet_diagnostic.RCS1266.severity = none # Use raw string literal — covered by SST2243
dotnet_diagnostic.RCS1267.severity = error # Use string interpolation instead of 'string.Concat'

# Performance
dotnet_diagnostic.RCS1077.severity = none # Covered by the PSH1101-PSH1111 family (canonical)
dotnet_diagnostic.RCS1080.severity = none # Covered by PSH1106 (canonical)
dotnet_diagnostic.RCS1112.severity = none # Combine 'Enumerable.Where' method chain — covered by PSH1109
dotnet_diagnostic.RCS1186.severity = error # Use Regex instance instead of static method
dotnet_diagnostic.RCS1190.severity = none # Join string expressions — conflicts with SST2470, which reports the fused-literal seam this would create
dotnet_diagnostic.RCS1195.severity = error # Use ^ operator
dotnet_diagnostic.RCS1197.severity = none # Optimize StringBuilder.Append/AppendLine call — covered by PSH1203/PSH1214
dotnet_diagnostic.RCS1198.severity = none # Avoid unnecessary boxing of value type — boxing is unavoidable bridging Rx and IEnumerable<object>
dotnet_diagnostic.RCS1230.severity = none # Unnecessary explicit use of enumerator — covered by SST1467
dotnet_diagnostic.RCS1235.severity = error # Optimize method call
dotnet_diagnostic.RCS1236.severity = none # Use exception filter — covered by SST2009
dotnet_diagnostic.RCS1246.severity = none # Use element access — covered by PSH1106

# Maintainability
dotnet_diagnostic.RCS1158.severity = none # Static member in generic type should use a type parameter — common factory pattern — covered by SST1431
dotnet_diagnostic.RCS1163.severity = none # Unused parameter — interface implementations and Rx selectors often have unused parameters
dotnet_diagnostic.RCS1164.severity = none # Unused type parameter - DUPLICATE IDE0060 (UnusedParameter analyzer 210ms; IDE0060 bundled at lower cost)
dotnet_diagnostic.RCS1165.severity = none # Unconstrained type parameter checked for null - we validate all parameters for non-nullable enabled platforms
dotnet_diagnostic.RCS1182.severity = none # Remove redundant base interface — covered by SST1177
dotnet_diagnostic.RCS1213.severity = none # Remove unused member declaration - DUPLICATE IDE0051 (slower: 230ms vs 75ms)
dotnet_diagnostic.RCS1241.severity = error # Implement non-generic counterpart
dotnet_diagnostic.RCS1256.severity = none # Invalid argument null check — conflicts with our ArgumentExceptionHelper helper pattern

# Documentation
dotnet_diagnostic.RCS1181.severity = error # Convert comment to documentation comment
dotnet_diagnostic.RCS1189.severity = error # Add or remove region name
dotnet_diagnostic.RCS1226.severity = none # Add paragraph to documentation comment — &lt;para&gt; wrapping is subjective and adds noise
dotnet_diagnostic.RCS1228.severity = error # Unused element in a documentation comment
dotnet_diagnostic.RCS1232.severity = error # Order elements in documentation comment
dotnet_diagnostic.RCS1253.severity = error # Format documentation comment summary
dotnet_diagnostic.RCS1263.severity = none # Invalid reference in a documentation comment

# Disabled
dotnet_diagnostic.RCS1018.severity = none # Add/remove accessibility modifiers — covered by SA1400
dotnet_diagnostic.RCS1019.severity = none # Order modifiers — covered by SA1206 / SA1208
dotnet_diagnostic.RCS1037.severity = none # Remove trailing white-space — covered by SA1028
dotnet_diagnostic.RCS1052.severity = none # Declare each attribute separately — covered by SA1133
dotnet_diagnostic.RCS1055.severity = none # Unnecessary semicolon at the end of declaration — covered by SA1106
dotnet_diagnostic.RCS1060.severity = none # Declare each type in separate file — covered by SA1402
dotnet_diagnostic.RCS1090.severity = none # Add/remove 'ConfigureAwait(false)' call — covered by CA2007 (also disabled)
dotnet_diagnostic.RCS1110.severity = none # Declare type inside namespace — covered by CA1050
dotnet_diagnostic.RCS1138.severity = none # Add summary to documentation comment — covered by SA1600
dotnet_diagnostic.RCS1139.severity = none # Add summary element to documentation comment — covered by SA1604
dotnet_diagnostic.RCS1140.severity = none # Add exception to documentation comment — covered by SA1614
dotnet_diagnostic.RCS1141.severity = none # Add 'param' element to documentation comment — covered by SA1611
dotnet_diagnostic.RCS1142.severity = none # Add 'typeparam' element to documentation comment — covered by SA1618
dotnet_diagnostic.RCS1175.severity = none # Unused 'this' parameter — covered by CA1822
dotnet_diagnostic.RCS1194.severity = none # Implement exception constructors — covered by CA1032
dotnet_diagnostic.RCS1203.severity = none # Use AttributeUsageAttribute — covered by CA1018

# Formatting
dotnet_diagnostic.RCS0001.severity = none # Add blank line after embedded statement — covered by StyleCop layout rules
dotnet_diagnostic.RCS0002.severity = none # Add blank line after #region — covered by StyleCop SA1517 family
dotnet_diagnostic.RCS0003.severity = none # Add blank line after using directive list — covered by SA1516
dotnet_diagnostic.RCS0005.severity = none # Add blank line before #endregion — covered by StyleCop layout rules
dotnet_diagnostic.RCS0006.severity = none # Add blank line before using directive list — covered by SA1517
dotnet_diagnostic.RCS0007.severity = none # Add blank line between accessors — covered by SA1513
dotnet_diagnostic.RCS0008.severity = none # Add blank line between closing brace and next statement — covered by SA1513
dotnet_diagnostic.RCS0009.severity = none # Add blank line between declaration and documentation comment — covered by SA1514
dotnet_diagnostic.RCS0010.severity = none # Add blank line between declarations — covered by SA1516
dotnet_diagnostic.RCS0011.severity = none # Add/remove blank line between single-line accessors — StyleCop already governs this
dotnet_diagnostic.RCS0012.severity = none # Add blank line between single-line declarations — covered by SA1516
dotnet_diagnostic.RCS0013.severity = none # Add blank line between single-line declarations of different kind — covered by SA1516
dotnet_diagnostic.RCS0015.severity = none # Add/remove blank line between using directives — covered by SA1209 / SA1210
dotnet_diagnostic.RCS0016.severity = none # Put attribute list on its own line — StyleCop SA1133 governs attribute lists
dotnet_diagnostic.RCS0020.severity = none # Format accessor's braces — covered by SA1500
dotnet_diagnostic.RCS0021.severity = none # Format block's braces — covered by SA1500
dotnet_diagnostic.RCS0023.severity = none # Format type declaration's braces — covered by SA1500
dotnet_diagnostic.RCS0024.severity = none # Add new line after switch label — covered by SA1003
dotnet_diagnostic.RCS0025.severity = none # Put full accessor on its own line — covered by SA1502
dotnet_diagnostic.RCS0027.severity = none # Place new line after/before binary operator — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0028.severity = none # Place new line after/before '?:' operator — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0029.severity = none # Put constructor initializer on its own line — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0030.severity = none # Put embedded statement on its own line — covered by SA1503
dotnet_diagnostic.RCS0031.severity = none # Put enum member on its own line — covered by SA1136
dotnet_diagnostic.RCS0032.severity = none # Place new line after/before arrow token — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0033.severity = none # Put statement on its own line — covered by SA1505 family
dotnet_diagnostic.RCS0034.severity = none # Put type parameter constraint on its own line — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0036.severity = none # Remove blank line between single-line declarations of same kind — covered by SA1516
dotnet_diagnostic.RCS0039.severity = none # Remove new line before base list — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0041.severity = none # Remove new line between 'if' keyword and 'else' keyword — StyleCop layout rules cover this
dotnet_diagnostic.RCS0042.severity = none # Put auto-accessors on a single line — formatting preference, not enforced
dotnet_diagnostic.RCS0044.severity = none # Use carriage return + linefeed as new line — handled by .gitattributes / editorconfig end_of_line
dotnet_diagnostic.RCS0045.severity = none # Use linefeed as new line — handled by .gitattributes / editorconfig end_of_line
dotnet_diagnostic.RCS0046.severity = none # Use spaces instead of tab — handled by editorconfig indent_style
dotnet_diagnostic.RCS0048.severity = none # Put initializer on a single line — formatting preference, not enforced
dotnet_diagnostic.RCS0049.severity = none # Add blank line after top comment — covered by SA1517
dotnet_diagnostic.RCS0050.severity = none # Add blank line before top declaration — covered by SA1517
dotnet_diagnostic.RCS0051.severity = none # Add/remove new line before 'while' in 'do' statement — formatting preference
dotnet_diagnostic.RCS0052.severity = none # Place new line after/before equals token — StyleCop wrapping rules cover this
dotnet_diagnostic.RCS0053.severity = none # Fix formatting of a list — formatting preference
dotnet_diagnostic.RCS0054.severity = none # Fix formatting of a call chain — formatting preference
dotnet_diagnostic.RCS0055.severity = none # Fix formatting of a binary expression chain — formatting preference
dotnet_diagnostic.RCS0056.severity = none # A line is too long — line-length not enforced
dotnet_diagnostic.RCS0057.severity = none # Normalize whitespace at the beginning of a file — handled by editorconfig
dotnet_diagnostic.RCS0058.severity = none # Normalize whitespace at the end of a file — covered by SST1518
dotnet_diagnostic.RCS0059.severity = none # Place new line after/before null-conditional operator — StyleSharp wrapping rules cover this
dotnet_diagnostic.RCS0060.severity = none # Add/remove line after file scoped namespace declaration — formatting preference
dotnet_diagnostic.RCS0061.severity = none # Add/remove blank line between switch sections — formatting preference
dotnet_diagnostic.RCS0062.severity = none # Put expression body on its own line — formatting preference
dotnet_diagnostic.RCS0063.severity = none # Remove unnecessary blank line — covered by SST1505 / SST1507

###################
# StyleSharp Analyzers (SST)
###################
file_header_template = Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.\nReactiveUI Association Incorporated licenses this file to you under the MIT license.\nSee the LICENSE file in the project root for full license information.
stylesharp.summary_single_line_max_length = 120

# SonarAnalyzer's S4022 only ever flagged storage narrower than int; uint, long and ulong
# passed silently. Match that, so retiring S4022 for SST2313 does not fail a build on an
# enum that was deliberately widened.
stylesharp.SST2313.allowed_enum_storage = int, uint, long, ulong

# Documentation coverage scope (SST1600/SST1601/SST1602/SST1654).
# Require documentation on every element, including private members.
stylesharp.document_exposed_elements = true
stylesharp.document_internal_elements = true
stylesharp.document_private_elements = true
stylesharp.document_private_fields = true
stylesharp.document_interfaces = all
stylesharp.SST1305.allowed_hungarian_prefixes = rx
stylesharp.instance_member_qualification = omit_this
stylesharp.max_cyclomatic_complexity = 10
stylesharp.max_cognitive_complexity = 15
stylesharp.max_property_cognitive_complexity = 3
# SST1484 also reports a field that shadows one inherited from a base type.
stylesharp.SST1484.check_base_types = true
stylesharp.max_line_length = 200                           # SST1521 (characters; keeps the limit this repo has always enforced)
stylesharp.max_file_lines = 1000                           # SST1522 (code lines; blank lines and comments do not count)
# stylesharp.max_member_lines = 60                         # SST1523 (code lines)
# stylesharp.max_switch_section_lines = 20                 # SST1524 (code lines)
# stylesharp.include_internal = true                       # SST1499 (set false to report only fields visible outside the assembly)
# stylesharp.require_parameterless = true                  # SST1488 (set false where every exception must carry a message)
# stylesharp.include_non_public_types = true               # SST1488 (set false to check only externally visible exceptions)
# Spacing
dotnet_diagnostic.SST1000.severity = error # A control-flow keyword is not followed by a space
dotnet_diagnostic.SST1001.severity = error # A comma is spaced incorrectly
dotnet_diagnostic.SST1002.severity = error # A semicolon is spaced incorrectly
dotnet_diagnostic.SST1003.severity = error # A binary operator is not surrounded by spaces
dotnet_diagnostic.SST1004.severity = error # A documentation comment line does not begin with a single space after the '///'
dotnet_diagnostic.SST1005.severity = error # A single-line comment does not begin with a single space
dotnet_diagnostic.SST1006.severity = error # A preprocessor keyword is preceded by a space after the '#'
dotnet_diagnostic.SST1007.severity = error # An operator keyword is not followed by a space
dotnet_diagnostic.SST1008.severity = error # An opening parenthesis is followed by a space
dotnet_diagnostic.SST1009.severity = error # A closing parenthesis is preceded by a space
dotnet_diagnostic.SST1010.severity = none # An opening square bracket has adjacent whitespace — conflicts with modern collection expressions
dotnet_diagnostic.SST1011.severity = error # A closing square bracket is preceded by a space
dotnet_diagnostic.SST1012.severity = error # An opening brace is not followed by a space on a single line
dotnet_diagnostic.SST1013.severity = error # A closing brace is not preceded by a space on a single line
dotnet_diagnostic.SST1014.severity = error # An opening generic bracket is preceded or followed by a space
dotnet_diagnostic.SST1015.severity = error # A closing generic bracket is preceded by a space
dotnet_diagnostic.SST1016.severity = error # An opening attribute bracket is followed by a space
dotnet_diagnostic.SST1017.severity = error # A closing attribute bracket is preceded by a space
dotnet_diagnostic.SST1018.severity = error # A nullable type symbol is preceded by a space
dotnet_diagnostic.SST1019.severity = error # A member access symbol is surrounded by spaces
dotnet_diagnostic.SST1020.severity = error # An increment or decrement symbol is separated from its operand by a space
dotnet_diagnostic.SST1021.severity = error # A unary negative sign is followed by a space
dotnet_diagnostic.SST1022.severity = error # A unary positive sign is followed by a space
dotnet_diagnostic.SST1023.severity = error # A dereference or address-of symbol is followed by a space
dotnet_diagnostic.SST1024.severity = error # A colon is spaced incorrectly for its context
dotnet_diagnostic.SST1025.severity = error # Two or more whitespace characters appear in a row within a line
dotnet_diagnostic.SST1026.severity = error # A space follows 'new' or 'stackalloc' in an implicit array creation
dotnet_diagnostic.SST1027.severity = error # A tab character is used where the project standardises on spaces
dotnet_diagnostic.SST1028.severity = error # A line ends with trailing whitespace

# Readability and maintainability
dotnet_diagnostic.SST1100.severity = error # A base. prefix is used where the type does not override the member
dotnet_diagnostic.SST1101.severity = none # see docs/rules/SST1101.md
dotnet_diagnostic.SST1102.severity = error # A query clause is separated from the previous clause by a blank line
dotnet_diagnostic.SST1103.severity = error # Query clauses mix single-line and multi-line layout
dotnet_diagnostic.SST1104.severity = error # A query clause shares the last line of a multi-line previous clause
dotnet_diagnostic.SST1105.severity = error # A multi-line query clause does not begin on its own line
dotnet_diagnostic.SST1106.severity = error # A statement is empty (a stray semicolon)
dotnet_diagnostic.SST1107.severity = error # More than one statement shares a line
dotnet_diagnostic.SST1110.severity = error # An opening parenthesis or bracket does not sit on the line of the preceding code
dotnet_diagnostic.SST1111.severity = error # A closing parenthesis or bracket does not sit on the last parameter's line
dotnet_diagnostic.SST1112.severity = error # An empty parameter list's closing parenthesis is on a different line
dotnet_diagnostic.SST1113.severity = error # A comma does not sit on the previous parameter's line
dotnet_diagnostic.SST1114.severity = error # A blank line separates the declaration from its parameter list
dotnet_diagnostic.SST1115.severity = error # A blank line separates a parameter from the preceding comma
dotnet_diagnostic.SST1116.severity = error # A qualified name can be shortened without changing the symbol it binds to
dotnet_diagnostic.SST1117.severity = error # Instance member access follows the configured this. qualification style
dotnet_diagnostic.SST1118.severity = none # A parameter should not span multiple lines
dotnet_diagnostic.SST1119.severity = error # A numeric literal groups its digit separators irregularly
dotnet_diagnostic.SST1120.severity = error # A comment contains no text
dotnet_diagnostic.SST1121.severity = error # A framework type name is used instead of its built-in alias (opt-in rule, enabled here)
dotnet_diagnostic.SST1122.severity = error # An empty string literal is used instead of string.Empty
dotnet_diagnostic.SST1123.severity = error # A #region is placed inside a code element body
dotnet_diagnostic.SST1124.severity = error # A #region directive is used
dotnet_diagnostic.SST1125.severity = error # A Nullable<T> type is written in long form instead of the T? shorthand
dotnet_diagnostic.SST1127.severity = error # A generic type constraint shares a line with the declaration or another constraint
dotnet_diagnostic.SST1128.severity = error # A constructor initializer shares a line with the constructor signature
dotnet_diagnostic.SST1129.severity = error # A value type is created with a parameterless constructor call instead of default
dotnet_diagnostic.SST1130.severity = error # An anonymous delegate is used where a lambda expression is clearer
dotnet_diagnostic.SST1131.severity = error # A comparison places the constant on the left ("yoda" condition)
dotnet_diagnostic.SST1132.severity = error # Several fields are declared in a single statement
dotnet_diagnostic.SST1133.severity = error # Several attributes share one bracket list
dotnet_diagnostic.SST1134.severity = error # An attribute shares a line with another attribute or the element
dotnet_diagnostic.SST1135.severity = error # A using directive names a namespace or type that is not fully qualified
dotnet_diagnostic.SST1136.severity = error # Several enum members share a line
dotnet_diagnostic.SST1137.severity = error # Sibling elements are indented differently from one another
dotnet_diagnostic.SST1138.severity = error # A free-standing block declares nothing
dotnet_diagnostic.SST1139.severity = error # A numeric literal is cast where a literal suffix would express the type
dotnet_diagnostic.SST1140.severity = error # Wrapped conditional operators should start indented continuation lines
dotnet_diagnostic.SST1141.severity = error # An explicit ValueTuple<...> is used where tuple syntax would do
dotnet_diagnostic.SST1142.severity = error # A tuple element is accessed by ItemN where it has a name
dotnet_diagnostic.SST1143.severity = error # A boolean expression is compared to a true/false literal
dotnet_diagnostic.SST1144.severity = error # Combine case labels with an or-pattern
dotnet_diagnostic.SST1145.severity = error # A wrapped conditional expression places ?/: inconsistently
dotnet_diagnostic.SST1146.severity = error # An if statement follows a closing brace on the same line
dotnet_diagnostic.SST1147.severity = error # Do not nest conditional operators
dotnet_diagnostic.SST1148.severity = error # Commented-out code should be removed
dotnet_diagnostic.SST1149.severity = error # Prefer the 'is null' pattern for null checks
dotnet_diagnostic.SST1150.severity = error # Require each constructor parameter on a unique line
dotnet_diagnostic.SST1151.severity = error # Require each method parameter on a unique line
dotnet_diagnostic.SST1152.severity = error # Require each delegate parameter on a unique line
dotnet_diagnostic.SST1153.severity = error # Require each indexer parameter on a unique line
dotnet_diagnostic.SST1154.severity = error # Require each invocation argument on a unique line
dotnet_diagnostic.SST1155.severity = error # Require each object creation argument on a unique line
dotnet_diagnostic.SST1156.severity = error # Require each element access argument on a unique line
dotnet_diagnostic.SST1157.severity = error # Require each attribute argument on a unique line
dotnet_diagnostic.SST1158.severity = error # Require each anonymous method parameter on a unique line
dotnet_diagnostic.SST1159.severity = error # Require each parenthesized lambda parameter on a unique line
dotnet_diagnostic.SST1160.severity = error # Require each record primary-constructor parameter on a unique line
dotnet_diagnostic.SST1161.severity = error # Require each class primary-constructor parameter on a unique line
dotnet_diagnostic.SST1162.severity = error # Require each struct primary-constructor parameter on a unique line
dotnet_diagnostic.SST1163.severity = error # Require each target-typed object creation argument on a unique line
dotnet_diagnostic.SST1164.severity = error # Require each constructor initializer argument on a unique line
dotnet_diagnostic.SST1165.severity = error # Require each primary-constructor base argument on a unique line
dotnet_diagnostic.SST1166.severity = error # Require each local-function parameter on a unique line
dotnet_diagnostic.SST1167.severity = error # Require each operator parameter on a unique line
dotnet_diagnostic.SST1168.severity = error # Require each conversion-operator parameter on a unique line
dotnet_diagnostic.SST1169.severity = error # Require each type parameter on a unique line
dotnet_diagnostic.SST1170.severity = error # Require each type argument on a unique line
dotnet_diagnostic.SST1171.severity = error # Require each function-pointer parameter on a unique line
dotnet_diagnostic.SST1172.severity = error # Negated comparisons should use the opposite operator
dotnet_diagnostic.SST1173.severity = error # Redundant anonymous-type member names should be omitted
dotnet_diagnostic.SST1174.severity = error # Redundant jump statements should be removed
dotnet_diagnostic.SST1175.severity = error # Unnecessary casts should be removed
dotnet_diagnostic.SST1176.severity = error # Members should not be initialized to their default value
dotnet_diagnostic.SST1177.severity = error # Redundant base types should be removed
dotnet_diagnostic.SST1178.severity = error # Redundant base constructor calls should be removed
dotnet_diagnostic.SST1179.severity = error # Redundant default switch sections should be removed
dotnet_diagnostic.SST1180.severity = error # Empty else clauses should be removed
dotnet_diagnostic.SST1181.severity = error # Redundant overriding members should be removed
dotnet_diagnostic.SST1182.severity = error # Conditional expressions should not just return boolean literals
dotnet_diagnostic.SST1183.severity = error # Interpolated strings without interpolations should be plain strings
dotnet_diagnostic.SST1184.severity = error # Verbatim string literals without escapes should be regular strings
dotnet_diagnostic.SST1185.severity = error # Use a compound assignment operator
dotnet_diagnostic.SST1186.severity = error # A literal should be on the right side of a comparison
dotnet_diagnostic.SST1187.severity = error # Assignments should not be chained
dotnet_diagnostic.SST1188.severity = error # Use the 'default' literal instead of 'default(T)'
dotnet_diagnostic.SST1189.severity = error # Variables should not be self-assigned
dotnet_diagnostic.SST1190.severity = error # Doubled negation operators should be removed
dotnet_diagnostic.SST1191.severity = error # Long numeric literals should use digit separators
dotnet_diagnostic.SST1192.severity = none # Control characters in string literals should be escaped
dotnet_diagnostic.SST1193.severity = error # Keep initial member values with construction
dotnet_diagnostic.SST1194.severity = error # Keep initial collection values with construction
dotnet_diagnostic.SST1195.severity = error # Write null fallback with ??
dotnet_diagnostic.SST1196.severity = error # Write null-guarded access with ?.
dotnet_diagnostic.SST1197.severity = error # Collapse return-only branches into one return
dotnet_diagnostic.SST1198.severity = error # Collapse assignment-only branches into one assignment
dotnet_diagnostic.SST1199.severity = error # Prefer compile-time type names

# Ordering
dotnet_diagnostic.SST1200.severity = error # Using directives should be placed outside the namespace
dotnet_diagnostic.SST1201.severity = error # Members should be ordered by kind
dotnet_diagnostic.SST1202.severity = error # Members should be ordered by accessibility
dotnet_diagnostic.SST1203.severity = error # Constants should appear before fields
dotnet_diagnostic.SST1204.severity = error # Static members should appear before instance members
dotnet_diagnostic.SST1205.severity = error # Partial elements should declare an access modifier
dotnet_diagnostic.SST1206.severity = error # Declaration keywords should follow the standard order
dotnet_diagnostic.SST1207.severity = error # Place protected before internal
dotnet_diagnostic.SST1208.severity = error # System using directives should appear before other usings
dotnet_diagnostic.SST1209.severity = error # Using alias directives should appear after other usings
dotnet_diagnostic.SST1210.severity = error # Regular using directives should be ordered alphabetically
dotnet_diagnostic.SST1211.severity = error # Using alias directives should be ordered alphabetically by alias
dotnet_diagnostic.SST1212.severity = error # Property accessors should be ordered with get first
dotnet_diagnostic.SST1213.severity = error # Event accessors should be ordered with add first
dotnet_diagnostic.SST1214.severity = error # Static readonly fields should appear before static non-readonly fields
dotnet_diagnostic.SST1215.severity = error # Instance readonly fields should appear before instance non-readonly fields
dotnet_diagnostic.SST1216.severity = error # Using static directives should be placed after regular usings and before aliases
dotnet_diagnostic.SST1217.severity = error # Using static directives should be ordered alphabetically
dotnet_diagnostic.SST1218.severity = error # Other members separate a method's overloads
dotnet_diagnostic.SST1219.severity = error # A switch default clause is not placed last
dotnet_diagnostic.SST1220.severity = error # An all-named argument list is in a different order than the parameters. Code fix reorders it to declaration order. Info.
dotnet_diagnostic.SST1221.severity = error # `where` constraint clauses are not ordered to match the type-parameter list. Code fix reorders them. Info.

# Naming
dotnet_diagnostic.SST1300.severity = none # Types and members should be PascalCase — naming duplicates existing analyzers
dotnet_diagnostic.SST1302.severity = error # Interface names should begin with I
dotnet_diagnostic.SST1303.severity = error # Const names should be PascalCase
dotnet_diagnostic.SST1304.severity = error # Non-private readonly fields should be PascalCase
dotnet_diagnostic.SST1305.severity = error # Field names should not use Hungarian notation
dotnet_diagnostic.SST1306.severity = none # Field names should begin with a lower-case letter — private fields use _camelCase here
dotnet_diagnostic.SST1307.severity = error # Accessible fields should be PascalCase
dotnet_diagnostic.SST1308.severity = none # Field names should not be prefixed with m_ or s_ — too broad for existing conventions
dotnet_diagnostic.SST1309.severity = error # Private fields should be _camelCase
dotnet_diagnostic.SST1310.severity = none # Field names should not contain underscores — conflicts with _camelCase
dotnet_diagnostic.SST1311.severity = none # Static readonly fields should be PascalCase — we use _camelCase for private static readonly too
dotnet_diagnostic.SST1312.severity = error # Local variables should be camelCase
dotnet_diagnostic.SST1313.severity = error # Parameters should be camelCase
dotnet_diagnostic.SST1314.severity = error # Type parameters should begin with T
dotnet_diagnostic.SST1315.severity = error # Union member names should match the configured casing
dotnet_diagnostic.SST1316.severity = none # Tuple element names should use the configured casing — tuple naming is not enforced here
dotnet_diagnostic.SST1317.severity = none # Asynchronous method names should end with 'Async' — conflicts with this project's Rx-compatibility and naming mechanism
dotnet_diagnostic.SST1318.severity = error # Overriding parameter names should match the base declaration
dotnet_diagnostic.SST1319.severity = error # An enumeration's type name is not PascalCase
dotnet_diagnostic.SST1320.severity = error # A parameter name matches its method's name
dotnet_diagnostic.SST1321.severity = none # Public APIs intentionally use Async to describe asynchronous observable behavior without returning an awaitable.

# Maintainability
dotnet_diagnostic.SST1400.severity = error # An element does not declare an access modifier
dotnet_diagnostic.SST1401.severity = error # A non-private, non-constant field is exposed
dotnet_diagnostic.SST1402.severity = error # A file declares more than one top-level type
dotnet_diagnostic.SST1403.severity = error # A file declares more than one namespace
dotnet_diagnostic.SST1404.severity = error # A code-analysis suppression has no justification
dotnet_diagnostic.SST1405.severity = error # A Debug.Assert call provides no message
dotnet_diagnostic.SST1406.severity = error # A Debug.Fail call provides no message
dotnet_diagnostic.SST1407.severity = error # Mixed-precedence arithmetic is not parenthesized
dotnet_diagnostic.SST1408.severity = error # Mixed conditional operators are not parenthesized
dotnet_diagnostic.SST1410.severity = error # An anonymous method has an empty parameter list
dotnet_diagnostic.SST1411.severity = error # An attribute uses an empty argument list
dotnet_diagnostic.SST1412.severity = none # Store files as UTF-8 with a byte order mark — conflicts with SST1450 (UTF-8 without BOM)
dotnet_diagnostic.SST1413.severity = none # A multi-line initializer omits the trailing comma — trailing commas are not required here
dotnet_diagnostic.SST1414.severity = error # A tuple type in a member signature has an unnamed element
dotnet_diagnostic.SST1415.severity = error # An argument-exception constructor uses a string literal where nameof would track renames
dotnet_diagnostic.SST1416.severity = none # Do not declare public members in a non-public type
dotnet_diagnostic.SST1417.severity = suggestion # Namespace should match the folder structure
dotnet_diagnostic.SST1418.severity = error # Declare precedence when mixing the null-coalescing operator
dotnet_diagnostic.SST1419.severity = error # Remove redundant modifiers
dotnet_diagnostic.SST1420.severity = error # Trivial properties should be auto-implemented
dotnet_diagnostic.SST1421.severity = error # Write-only properties should not be used
dotnet_diagnostic.SST1422.severity = error # Private fields used only as locals should be local variables
dotnet_diagnostic.SST1423.severity = error # Switch statements should not have too many sections
dotnet_diagnostic.SST1424.severity = error # Fields that are never reassigned should be readonly
dotnet_diagnostic.SST1425.severity = error # Do not reassign captured primary-constructor parameters
dotnet_diagnostic.SST1426.severity = error # Use [SuppressMessage] instead of #pragma warning disable
dotnet_diagnostic.SST1427.severity = error # Protected members of sealed types should not be used
dotnet_diagnostic.SST1428.severity = error # Abstract types should not declare public constructors
dotnet_diagnostic.SST1429.severity = error # Empty catch clauses should not swallow the base exception
dotnet_diagnostic.SST1430.severity = error # Rethrow with 'throw;' to preserve the stack trace
dotnet_diagnostic.SST1431.severity = error # Static members of a generic type should use a type parameter
dotnet_diagnostic.SST1432.severity = error # Classes with only static members should be static
dotnet_diagnostic.SST1433.severity = error # Redundant constructors should be removed
dotnet_diagnostic.SST1434.severity = error # see docs/rules/SST1434.md
dotnet_diagnostic.SST1435.severity = error # Empty namespace declarations should be removed
dotnet_diagnostic.SST1436.severity = error # Empty types should not be declared
dotnet_diagnostic.SST1437.severity = error # Empty interfaces should not be declared
dotnet_diagnostic.SST1438.severity = error # Methods should not be empty
dotnet_diagnostic.SST1439.severity = error # Nested code blocks should not be left empty
dotnet_diagnostic.SST1440.severity = error # Private members with no local use should be removed
dotnet_diagnostic.SST1441.severity = error # Private fields assigned but never read should be removed
dotnet_diagnostic.SST1442.severity = error # A function has too many direct branch points
dotnet_diagnostic.SST1443.severity = error # A function has too much nested control flow
dotnet_diagnostic.SST1444.severity = error # A loop cannot naturally reach a second iteration
dotnet_diagnostic.SST1445.severity = error # A using directive is unnecessary
dotnet_diagnostic.SST1446.severity = error # An inheritance chain is deeper than the configured maximum
dotnet_diagnostic.SST1447.severity = error # An equality override delegates to object reference semantics
dotnet_diagnostic.SST1448.severity = error # An argument is passed explicitly to a caller-info parameter
dotnet_diagnostic.SST1449.severity = error # Code writes directly to the console
dotnet_diagnostic.SST1450.severity = error # Store files as UTF-8 without a byte order mark
dotnet_diagnostic.SST1451.severity = error # A DateTime is created without a DateTimeKind
dotnet_diagnostic.SST1452.severity = error # A generic type parameter is never used
dotnet_diagnostic.SST1453.severity = error # Statements after an unconditional exit should be removed
dotnet_diagnostic.SST1454.severity = error # Composite format placeholders should match the supplied arguments
dotnet_diagnostic.SST1455.severity = error # Unsafe modifiers should be used only when unsafe syntax is present
dotnet_diagnostic.SST1456.severity = error # Readonly fields should not store mutable source-defined structs
dotnet_diagnostic.SST1457.severity = error # Global suppressions should point at real declarations
dotnet_diagnostic.SST1458.severity = error # Global suppression targets should use declaration ids directly
dotnet_diagnostic.SST1459.severity = error # Grouping parentheses should be removed when the parent syntax already isolates the expression
dotnet_diagnostic.SST1460.severity = error # Non-mutating struct members should be readonly
dotnet_diagnostic.SST1461.severity = error # Private parameters that are never read should be removed
dotnet_diagnostic.SST1462.severity = error # Suppressions for diagnostics already disabled by config should be removed
dotnet_diagnostic.SST1463.severity = error # Symbol-name strings should use nameof
dotnet_diagnostic.SST1464.severity = error # An else clause follows a branch that always jumps and can be unwrapped
dotnet_diagnostic.SST1465.severity = error # An else block that only wraps an if can collapse to else-if
dotnet_diagnostic.SST1466.severity = error # A case label sharing a section with default is redundant
dotnet_diagnostic.SST1467.severity = error # A hand-driven enumerator loop can use foreach
dotnet_diagnostic.SST1468.severity = error # Boolean logic should use the short-circuiting && and || operators
dotnet_diagnostic.SST1469.severity = error # A non-nullable value type is compared to null
dotnet_diagnostic.SST1470.severity = error # A trailing catch clause that only rethrows should be removed
dotnet_diagnostic.SST1471.severity = error # Magic numbers should be named constants
dotnet_diagnostic.SST1472.severity = error # Signatures should not declare too many parameters
dotnet_diagnostic.SST1473.severity = error # A floating-point value is compared for exact equality (zero comparison allowed by default)
dotnet_diagnostic.SST1474.severity = error # Both sides of an operator are the same expression
dotnet_diagnostic.SST1475.severity = error # A condition repeats an earlier one in the chain, so its branch cannot run
dotnet_diagnostic.SST1476.severity = error # Every branch of a conditional has the same body
dotnet_diagnostic.SST1477.severity = error # An integer division is widened to floating point after it has already truncated
dotnet_diagnostic.SST1478.severity = error # A shift count is zero, negative, or at least the operand's width
dotnet_diagnostic.SST1479.severity = error # A count or length is compared against a value it can never take
dotnet_diagnostic.SST1480.severity = error # An exception is constructed and then discarded
dotnet_diagnostic.SST1481.severity = error # A bitwise operation has a constant operand that makes it pointless
dotnet_diagnostic.SST1482.severity = error # GetHashCode reads mutable state
dotnet_diagnostic.SST1483.severity = error # A constructor calls an overridable member
dotnet_diagnostic.SST1484.severity = error # A declaration shadows an outer field or property (inherited fields included)
dotnet_diagnostic.SST1485.severity = error # A member that must not throw throws
dotnet_diagnostic.SST1486.severity = error # The same string literal is repeated instead of being named
dotnet_diagnostic.SST1487.severity = error # A collection element is assigned twice with nothing reading it in between
dotnet_diagnostic.SST1488.severity = error # An exception type does not declare the standard constructors (parameterless waivable)
dotnet_diagnostic.SST1489.severity = error # An exception type carries serialization members the target framework has obsoleted
dotnet_diagnostic.SST1490.severity = error # A base list names an interface the rest of the list already implies
dotnet_diagnostic.SST1491.severity = error # A modifier restates the declaration's default
dotnet_diagnostic.SST1492.severity = error # A value is tested against what it is then assigned, so the guard decides nothing
dotnet_diagnostic.SST1493.severity = error # A method's whole body is a constant
dotnet_diagnostic.SST1494.severity = error # A trailing argument repeats the parameter's default
dotnet_diagnostic.SST1495.severity = error # '==' compares references on a type that overrides Equals, so the two disagree
dotnet_diagnostic.SST1496.severity = error # An abstract type declares nothing abstract
dotnet_diagnostic.SST1497.severity = error # A local is declared and never read
dotnet_diagnostic.SST1498.severity = error # Only a nested type uses a private member
dotnet_diagnostic.SST1499.severity = error # A static field visible outside its type can still be changed (internal fields included by default)

# Layout
dotnet_diagnostic.SST1500.severity = error # A brace in a multi-line construct shares its line with other code
dotnet_diagnostic.SST1501.severity = error # A statement block is collapsed onto a single line
dotnet_diagnostic.SST1502.severity = error # An element body is collapsed onto a single line
dotnet_diagnostic.SST1503.severity = none # A control-flow statement omits the braces around its child statement — duplicate with existing brace preferences
dotnet_diagnostic.SST1504.severity = error # The accessors of a property/event mix single-line and multi-line forms
dotnet_diagnostic.SST1505.severity = error # An opening brace is followed by a blank line
dotnet_diagnostic.SST1506.severity = error # An element documentation header is followed by a blank line
dotnet_diagnostic.SST1507.severity = error # Two or more blank lines appear in a row
dotnet_diagnostic.SST1508.severity = error # A closing brace is preceded by a blank line
dotnet_diagnostic.SST1509.severity = error # An opening brace is preceded by a blank line
dotnet_diagnostic.SST1510.severity = error # A chained block such as else/catch/finally is preceded by a blank line
dotnet_diagnostic.SST1511.severity = error # The while footer of a do/while loop is preceded by a blank line
dotnet_diagnostic.SST1512.severity = error # A single-line comment is followed by a blank line
dotnet_diagnostic.SST1513.severity = error # A closing brace is not followed by a blank line
dotnet_diagnostic.SST1514.severity = error # An element documentation header is not preceded by a blank line
dotnet_diagnostic.SST1515.severity = error # A single-line comment is not preceded by a blank line
dotnet_diagnostic.SST1516.severity = error # Adjacent members or namespace elements are not separated by a blank line
dotnet_diagnostic.SST1517.severity = error # The file begins with one or more blank lines
dotnet_diagnostic.SST1518.severity = error # The file does not end with exactly one newline
dotnet_diagnostic.SST1519.severity = error # A multi-line child statement of a control-flow keyword omits its braces
dotnet_diagnostic.SST1520.severity = error # The clauses of an if/else chain use braces inconsistently
dotnet_diagnostic.SST1521.severity = error # A line is longer than the configured maximum (default 120 characters)
dotnet_diagnostic.SST1522.severity = error # A file has more code lines than the configured maximum (default 500)
dotnet_diagnostic.SST1523.severity = error # A member has more code lines than the configured maximum (default 60)
dotnet_diagnostic.SST1524.severity = error # A switch section has more code lines than the configured maximum (default 20)
dotnet_diagnostic.SST1525.severity = error # A multi-statement `switch` section has no braces; the braces-on policy extends to switch sections. Code fix wraps it.
dotnet_diagnostic.SST1526.severity = error # A wrapped binary expression places the operator inconsistently. Configurable (`before`/`after`, default before). Opt-in.
dotnet_diagnostic.SST1527.severity = error # The `=>` of an expression-bodied member wraps inconsistently. Configurable. Opt-in.
dotnet_diagnostic.SST1528.severity = error # The `=` of a wrapped initializer wraps inconsistently. Configurable. Opt-in.
dotnet_diagnostic.SST1529.severity = error # A wrapped `?.`/`.` call chain places the break inconsistently. Configurable. Opt-in.
dotnet_diagnostic.SST1530.severity = error # A newline sits between a type declaration and its base list. Code fix pulls the base list onto the declaration line. Opt-in.
dotnet_diagnostic.SST1531.severity = error # A short object initializer is split across lines. Code fix collapses it when it fits. Opt-in.
dotnet_diagnostic.SST1532.severity = error # A file mixes line endings. Configurable (`lf`/`crlf`, default lf). Opt-in.
dotnet_diagnostic.SST1533.severity = error # A source file contains no code. Opt-in.

# Documentation
dotnet_diagnostic.SST1600.severity = error # Externally visible members should be documented
dotnet_diagnostic.SST1601.severity = error # Partial elements should be documented
dotnet_diagnostic.SST1602.severity = error # Enumeration members should be documented
dotnet_diagnostic.SST1604.severity = error # Element documentation should contain a summary
dotnet_diagnostic.SST1605.severity = error # Partial element documentation should have a summary
dotnet_diagnostic.SST1606.severity = error # The summary should have text
dotnet_diagnostic.SST1607.severity = error # Partial element summary should have text
dotnet_diagnostic.SST1608.severity = error # Documentation should not use the default placeholder summary
dotnet_diagnostic.SST1609.severity = none # Property documentation should have a value
dotnet_diagnostic.SST1610.severity = error # Property value documentation should have text
dotnet_diagnostic.SST1611.severity = error # Parameters should be documented
dotnet_diagnostic.SST1612.severity = error # Parameter documentation should match the parameters
dotnet_diagnostic.SST1613.severity = error # Parameter documentation should declare a name
dotnet_diagnostic.SST1614.severity = error # Parameter documentation should have text
dotnet_diagnostic.SST1615.severity = error # The return value should be documented

dotnet_diagnostic.SST1616.severity = error # Return value documentation should have text
dotnet_diagnostic.SST1617.severity = error # A void return value should not be documented
dotnet_diagnostic.SST1618.severity = error # Generic type parameters should be documented
dotnet_diagnostic.SST1619.severity = error # Partial generic type parameters should be documented
dotnet_diagnostic.SST1620.severity = error # Type parameter documentation should match the type parameters
dotnet_diagnostic.SST1621.severity = error # Type parameter documentation should declare a name
dotnet_diagnostic.SST1622.severity = error # Type parameter documentation should have text
dotnet_diagnostic.SST1623.severity = error # Property summaries should describe their accessors
dotnet_diagnostic.SST1624.severity = error # Property summary should omit a restricted set accessor
dotnet_diagnostic.SST1625.severity = error # Element documentation should not be copy-pasted
dotnet_diagnostic.SST1626.severity = error # A documentation-style comment is used where it does not document an element
dotnet_diagnostic.SST1627.severity = error # Documentation text should not be empty
dotnet_diagnostic.SST1628.severity = error # Documentation text should begin with a capital letter
dotnet_diagnostic.SST1629.severity = error # Documentation text should end with a period
dotnet_diagnostic.SST1630.severity = error # Documentation text should contain whitespace
dotnet_diagnostic.SST1631.severity = error # Documentation text should be mostly letters
dotnet_diagnostic.SST1632.severity = error # Documentation text should meet a minimum length
dotnet_diagnostic.SST1633.severity = error # Files should begin with the configured header
dotnet_diagnostic.SST1642.severity = error # Constructor summaries should begin with the standard text
dotnet_diagnostic.SST1643.severity = error # Destructor summaries should begin with the standard text
dotnet_diagnostic.SST1644.severity = error # Documentation headers should not contain blank lines
dotnet_diagnostic.SST1648.severity = error # inheritdoc should be used with inheriting elements
dotnet_diagnostic.SST1649.severity = error # The file name should match the first type name
dotnet_diagnostic.SST1651.severity = error # Placeholder documentation elements should be removed
dotnet_diagnostic.SST1653.severity = error # Keep short documentation summaries on a single line
dotnet_diagnostic.SST1654.severity = error # Extension blocks should be documented with a summary
dotnet_diagnostic.SST1655.severity = error # Extension block parameters should be documented
dotnet_diagnostic.SST1656.severity = error # Extension block type parameters should be documented
dotnet_diagnostic.SST1657.severity = error # Extension block documentation should reference a real parameter or type parameter
dotnet_diagnostic.SST1658.severity = error # Documentation text repeats a word
dotnet_diagnostic.SST1659.severity = error # A comment has no text at all
dotnet_diagnostic.SST1660.severity = error # The `<param>` tags are not in parameter order. Code fix reorders them. Info.
dotnet_diagnostic.SST1661.severity = error # A snippet uses `<c>`/`<code>` mismatched to single- vs multi-line content. Code fix swaps the tag. Info.
dotnet_diagnostic.SST1662.severity = none # A thrown exception type has no `<exception>` documentation. Code fix adds the skeleton. Opt-in.
dotnet_diagnostic.SST1663.severity = none # A `//` comment before a public member reads like a summary; use `///`. Code fix converts it. Opt-in.
dotnet_diagnostic.SST1664.severity = none # A summary separates paragraphs with blank lines instead of `<para>`. Code fix wraps them. Opt-in.

# Concurrency and modernization
dotnet_diagnostic.SST1900.severity = error # see docs/rules/SST1900.md
dotnet_diagnostic.SST1901.severity = error # A lock targets a field or property reachable from outside the declaring type
dotnet_diagnostic.SST1902.severity = error # Do not lock on 'this', a Type, or a string
dotnet_diagnostic.SST1903.severity = error # Do not lock on a newly-created object
dotnet_diagnostic.SST1904.severity = error # A lock targets a non-readonly field
dotnet_diagnostic.SST1905.severity = error # An async method or converted delegate returns void
dotnet_diagnostic.SST2000.severity = suggestion # A null check plus throw should use ArgumentNullException.ThrowIfNull
dotnet_diagnostic.SST2001.severity = error # Use ArgumentException.ThrowIfNullOrEmpty
dotnet_diagnostic.SST2002.severity = error # Use ArgumentException.ThrowIfNullOrWhiteSpace
dotnet_diagnostic.SST2003.severity = suggestion # A disposed check should use ObjectDisposedException.ThrowIf
dotnet_diagnostic.SST2004.severity = suggestion # A range check should use an ArgumentOutOfRangeException.ThrowIf... helper
dotnet_diagnostic.SST2005.severity = error # Use the 'is' type pattern instead of comparing an 'as' cast to null
dotnet_diagnostic.SST2006.severity = error # Use the 'is not' pattern instead of negating an 'is' check
dotnet_diagnostic.SST2007.severity = error # Use declaration patterns instead of an is check followed by a cast local
dotnet_diagnostic.SST2008.severity = error # Negated pattern tests should use is-not patterns
dotnet_diagnostic.SST2009.severity = error # A catch that tests then rethrows can use a when filter
dotnet_diagnostic.SST2010.severity = error # A type reads the machine clock directly instead of through a TimeProvider
dotnet_diagnostic.SST2011.severity = error # An instant is recorded from the local clock rather than in UTC
dotnet_diagnostic.SST2012.severity = error # A GUID is constructed with the parameterless constructor instead of Guid.Empty
dotnet_diagnostic.SST2013.severity = error # An if whose entire body is another if should be merged
dotnet_diagnostic.SST2014.severity = error # A goto jumps to a label
dotnet_diagnostic.SST2015.severity = error # A ++ or -- is buried inside a larger expression
dotnet_diagnostic.SST2016.severity = error # A DateTime on a visible signature loses its offset at the boundary
dotnet_diagnostic.SST2017.severity = error # A .Date or .TimeOfDay read proves the value is only a date, or only a time of day
dotnet_diagnostic.SST2018.severity = error # A redundant null check sits beside an is type pattern

# Modern language and library usage
dotnet_diagnostic.SST1700.severity = error # An extension block declares no members
dotnet_diagnostic.SST1701.severity = error # Two extension blocks in a type share the same receiver type
dotnet_diagnostic.SST1702.severity = error # Extension blocks in a type are separated by other members
dotnet_diagnostic.SST1703.severity = error # A classic this-parameter extension method is used where an extension block could be
dotnet_diagnostic.SST1704.severity = error # A class declaring extension blocks is not named with an Extensions suffix
dotnet_diagnostic.SST1705.severity = error # A class mixes classic extension methods with extension blocks
dotnet_diagnostic.SST1706.severity = error # An extension block targets a broad receiver type such as object or dynamic
dotnet_diagnostic.SST1707.severity = error # Extension blocks should be ordered by receiver type
dotnet_diagnostic.SST1708.severity = error # An extension method never uses its `this` receiver, so it need not be an extension.
dotnet_diagnostic.SST1709.severity = none # A method in a `*Extensions` class whose first parameter lacks `this`. Code fix converts it to an extension block. Opt-in.
dotnet_diagnostic.SST1800.severity = error # Record classes should be sealed
dotnet_diagnostic.SST1801.severity = error # A positional record parameter does not match the configured casing
dotnet_diagnostic.SST1802.severity = error # A record declares a settable rather than init-only instance property
dotnet_diagnostic.SST1803.severity = error # A record struct is not declared readonly
dotnet_diagnostic.SST1804.severity = error # A positional record has an empty `{ }` body where `;` would do. Code fix rewrites it. Info.
dotnet_diagnostic.SST2100.severity = error # An empty collection creation can use []
dotnet_diagnostic.SST2101.severity = error # An explicit collection creation can use [...]
dotnet_diagnostic.SST2102.severity = error # A span-targeted stackalloc initializer can use a collection expression
dotnet_diagnostic.SST2103.severity = error # A collection-builder factory call can use a collection expression
dotnet_diagnostic.SST2104.severity = error # A short builder-local sequence can return a collection expression
dotnet_diagnostic.SST2105.severity = error # A literal array materialized with LINQ can use the target collection expression directly
dotnet_diagnostic.SST2200.severity = error # A single-use backing field can use the C# 14 field keyword
dotnet_diagnostic.SST2201.severity = error # A return-only switch statement can use a switch expression
dotnet_diagnostic.SST2202.severity = error # An object creation repeats an explicit target type
dotnet_diagnostic.SST2203.severity = error # An array or string index can use from-end indexing
dotnet_diagnostic.SST2204.severity = error # A string slice can use range syntax
dotnet_diagnostic.SST2205.severity = none # An enum switch statement omits named enum values — duplicate of IDE0010 (disabled: too noisy for default/fallthrough) and S131; statement switches deliberately no-op omitted values, and a default to satisfy it is rejected by SST1179/S3532. SST2206 keeps the valuable switch-expression exhaustiveness check.
dotnet_diagnostic.SST2206.severity = error # An enum switch expression omits named enum values
dotnet_diagnostic.SST2207.severity = error # A null guard and return can keep the throw in the returned expression
dotnet_diagnostic.SST2208.severity = error # An out variable can be declared at the call site
dotnet_diagnostic.SST2209.severity = none # A null-forgiving operator has no local effect
dotnet_diagnostic.SST2210.severity = error # A nullable directive repeats the current file-local state
dotnet_diagnostic.SST2211.severity = error # A nullable restore directive has no file-local state to restore
dotnet_diagnostic.SST2212.severity = error # Literal UTF-8 byte data can use a u8 string literal
dotnet_diagnostic.SST2213.severity = error # A typed pattern has an unnecessary discard designation
dotnet_diagnostic.SST2214.severity = error # A tuple temporary only feeds copied element locals
dotnet_diagnostic.SST2215.severity = error # A temporary local swaps two locals
dotnet_diagnostic.SST2216.severity = error # A tuple element name repeats the inferred name
dotnet_diagnostic.SST2217.severity = error # A manual hash-code expression can use System.HashCode.Combine
dotnet_diagnostic.SST2218.severity = error # Lambda parameter types can be omitted when the target already supplies them
dotnet_diagnostic.SST2219.severity = error # A single-expression property accessor can use an expression body
dotnet_diagnostic.SST2220.severity = error # An interpolation hole can carry the value and literal format directly
dotnet_diagnostic.SST2221.severity = error # An ignored expression value is assigned to the discard
dotnet_diagnostic.SST2222.severity = error # A local value is overwritten before it is read
dotnet_diagnostic.SST2223.severity = error # A null fallback assignment can use ??=
dotnet_diagnostic.SST2224.severity = error # An anonymous object can become a tuple literal for local value bundles
dotnet_diagnostic.SST2225.severity = error # A foreach loop hides an explicit element cast
dotnet_diagnostic.SST2226.severity = error # A cast hides an inner explicit conversion
dotnet_diagnostic.SST2227.severity = error # A post-assignment null fallback can be folded into the assigned expression
dotnet_diagnostic.SST2228.severity = error # A delegate local used only as a call target can be a local function
dotnet_diagnostic.SST2229.severity = error # see docs/rules/SST2229.md
dotnet_diagnostic.SST2230.severity = error # see docs/rules/SST2230.md
dotnet_diagnostic.SST2231.severity = error # A broad object pattern can use a direct null pattern
dotnet_diagnostic.SST2232.severity = error # nameof does not need concrete generic type arguments
dotnet_diagnostic.SST2233.severity = none # see docs/rules/SST2233.md
dotnet_diagnostic.SST2234.severity = error # Nullable<T> should use the T? shorthand
dotnet_diagnostic.SST2235.severity = error # Capture-free local functions should be static
dotnet_diagnostic.SST2236.severity = error # Tail-position using blocks can use using declarations
dotnet_diagnostic.SST2237.severity = error # Single block-scoped namespaces can use file-scoped syntax
dotnet_diagnostic.SST2238.severity = error # Nested property patterns can use extended property syntax
dotnet_diagnostic.SST2239.severity = error # Forwarding lambdas can use method groups
dotnet_diagnostic.SST2240.severity = error # Delegate null checks can use conditional invocation
dotnet_diagnostic.SST2241.severity = error # Constructors that only store parameters can use primary-constructor storage
dotnet_diagnostic.SST2242.severity = error # Enum switch statement mappings should name every enum value or include a catch-all
dotnet_diagnostic.SST2243.severity = error # A verbatim string with escapes or line breaks can use a raw string literal
dotnet_diagnostic.SST2244.severity = error # A numeric literal's suffix is lower case
dotnet_diagnostic.SST2245.severity = error # A for loop with only a condition should be a while loop
dotnet_diagnostic.SST2246.severity = error # A chain of conditional expressions testing one value against constants can be a switch expression
dotnet_diagnostic.SST2247.severity = error # Consecutive locals copying one value's members in order can be a deconstruction
dotnet_diagnostic.SST2248.severity = error # Two constant comparisons of the same value can fold into one is-pattern
dotnet_diagnostic.SST2249.severity = error # A literal-format string.Format or literal concatenation can be an interpolated string
dotnet_diagnostic.SST2250.severity = error # A bare local assigned once by the next statement can be an initialized declaration
dotnet_diagnostic.SST2251.severity = error # A method call names type arguments that inference would supply
dotnet_diagnostic.SST2252.severity = error # A switch statement is nested inside another switch statement
dotnet_diagnostic.SST2254.severity = none # A target-typed `new()` is written where an explicit type reads more clearly; the code fix restores `new TypeName(...)`. Opt-in — the counterpart to SST2202's target-typed direction, so a team enables at most one.
dotnet_diagnostic.SST2255.severity = error # A hand-written null-or-empty string test. Code fix uses `string.IsNullOrEmpty`.
dotnet_diagnostic.SST2256.severity = error # An extension method called in static form. Code fix rewrites to instance form. Info.
dotnet_diagnostic.SST2257.severity = error # A lambda block body that is a single `return`. Code fix uses an expression body. Info.
dotnet_diagnostic.SST2258.severity = error # A redundant explicit delegate wrapper (`new EventHandler(M)`). Code fix drops it. Info.
dotnet_diagnostic.SST2259.severity = error # A stray `;` after a type declaration. Code fix removes it. Info.
dotnet_diagnostic.SST2260.severity = error # An `as` cast to a type the operand already has. Code fix removes it. Info.
dotnet_diagnostic.SST2261.severity = error # `(x && !y)
dotnet_diagnostic.SST2262.severity = error # A raw string literal whose content needs no raw syntax. Code fix demotes it. Info.
dotnet_diagnostic.SST2263.severity = error # An infinite loop whose body re-derives its stop condition. Code fix hoists the condition into the header. Info.
dotnet_diagnostic.SST2264.severity = error # A numeric literal cast to an enum. Code fix names the member.
dotnet_diagnostic.SST2265.severity = none # Consecutive fluent calls on one receiver can fold into a chain. Opt-in.
dotnet_diagnostic.SST2266.severity = none # A local read exactly once can be inlined into that use. Opt-in.
dotnet_diagnostic.SST2267.severity = none # Infinite loops written in mixed `while(true)`/`for(;;)` styles. Configurable. Opt-in.
dotnet_diagnostic.SST2268.severity = none # Inconsistent `()` on object creation with an initializer. Configurable. Opt-in.
dotnet_diagnostic.SST2269.severity = none # Inconsistent parentheses around a conditional's condition. Configurable. Opt-in.
dotnet_diagnostic.SST2270.severity = none # Inconsistent explicit-vs-implicit array-creation type. Configurable. Opt-in.
dotnet_diagnostic.SST2271.severity = none # `var`-vs-explicit local type per the configured preference. Configurable. Opt-in.
dotnet_diagnostic.SST2272.severity = none # `[Flags]` member values written as mixed decimals and shifts. Configurable. Opt-in.
dotnet_diagnostic.SST2273.severity = none # A function or loop body wraps its work in a trailing `if` that could be an early-exit guard clause. Code fix inverts it. Configurable threshold. Opt-in.
dotnet_diagnostic.SST2274.severity = error # A value assigned with `as` and then null-checked is an `is` declaration pattern in one step. Code fix rewrites it.
dotnet_diagnostic.SST2275.severity = error # A method whose block body is a single statement can use an expression body `=> expr`. Code fix rewrites it.
dotnet_diagnostic.SST2276.severity = none # A constructor whose block body is a single statement can use an expression body. Code fix rewrites it. Opt-in.
dotnet_diagnostic.SST2277.severity = none # An operator whose block body is a single `return` can use an expression body. Code fix rewrites it. Opt-in.
dotnet_diagnostic.SST2278.severity = none # A conversion operator whose block body is a single `return` can use an expression body. Code fix rewrites it. Opt-in.
dotnet_diagnostic.SST2279.severity = error # A get-only property whose getter is a single `return` can use a whole-member expression body. Code fix rewrites it.
dotnet_diagnostic.SST2280.severity = error # A get-only indexer whose getter is a single `return` can use a whole-member expression body. Code fix rewrites it.
dotnet_diagnostic.SST2281.severity = error # A local function whose block body is a single statement can use an expression body. Code fix rewrites it.
dotnet_diagnostic.SST2282.severity = error # A reference-type `ReferenceEquals` check against `null` reads as an `is null` / `is not null` pattern. Code fix rewrites it.
dotnet_diagnostic.SST2283.severity = error # A null guard that throws right before assigning the guarded value can fold into the assignment as `?? throw`. Code fix rewrites it.
# Design
dotnet_diagnostic.SST2300.severity = error # A class implements IDisposable but builds only half of the disposal pattern
dotnet_diagnostic.SST2301.severity = error # A class implementing IEquatable<T> for itself can still be derived from
dotnet_diagnostic.SST2302.severity = error # A type overloads an operator without the rest of the set it belongs to
dotnet_diagnostic.SST2303.severity = error # A [Flags] enum's members are not distinct bit values
dotnet_diagnostic.SST2304.severity = error # An event's delegate does not have the standard (object sender, TEventArgs e) shape
dotnet_diagnostic.SST2305.severity = error # A mutable collection property declares a caller-visible setter
dotnet_diagnostic.SST2306.severity = error # A collection-returning member hands back null
dotnet_diagnostic.SST2307.severity = error # A generic method's type parameter appears in no parameter, so no caller can infer it
dotnet_diagnostic.SST2308.severity = error # An [Obsolete] attribute carries no message
dotnet_diagnostic.SST2309.severity = error # An externally visible member declares an optional parameter, so callers bake in the default
dotnet_diagnostic.SST2310.severity = error # Deprecated code is still here; remove it once its last caller is gone
dotnet_diagnostic.SST2311.severity = error # A visible const is copied into every assembly that reads it
dotnet_diagnostic.SST2312.severity = error # A type is declared outside any namespace
dotnet_diagnostic.SST2313.severity = error # An enum is stored as a type the project does not allow
dotnet_diagnostic.SST2314.severity = none # An [Obsolete] has a message but no DiagnosticId — unusable here: ObsoleteAttribute.DiagnosticId is .NET 5+, and this source is shared with net462
dotnet_diagnostic.SST2315.severity = error # A type owns a disposable field but does not implement IDisposable
dotnet_diagnostic.SST2316.severity = error # A type declares Dispose or DisposeAsync without implementing IDisposable
dotnet_diagnostic.SST2317.severity = error # A disposable type owns a raw IntPtr without a SafeHandle or finalizer
dotnet_diagnostic.SST2318.severity = error # Two members have token-identical bodies
dotnet_diagnostic.SST2319.severity = error # An overload's optional default can never be used
dotnet_diagnostic.SST2320.severity = error # An interface inherits two interfaces that declare the same member
dotnet_diagnostic.SST2321.severity = error # Environment.Exit or Environment.FailFast is called from library code
dotnet_diagnostic.SST2322.severity = error # A non-private readonly field holds a mutable collection callers can still change
dotnet_diagnostic.SST2323.severity = error # A stateless abstract class declaring only public abstract members should be an interface
dotnet_diagnostic.SST2324.severity = error # A member is declared more accessible than its containing type
dotnet_diagnostic.SST2325.severity = error # An async method checks an argument after its first await
dotnet_diagnostic.SST2326.severity = none # An interface-typed value is narrowed to a concrete implementation — this is a high-performance core library, not strictly SOLID code, and narrowing to a known runtime type is a normal fast-path technique here: foreach over IEnumerable<T> boxes List<T>'s struct enumerator (40 bytes per call, measured) where the indexed loop behind the type test allocates nothing
dotnet_diagnostic.SST2327.severity = error # A type tests its own runtime type against a class instead of dispatching through a virtual member
dotnet_diagnostic.SST2328.severity = error # A raw native pointer handle is exposed instead of a SafeHandle
dotnet_diagnostic.SST2329.severity = error # A `[Flags]` enum declares no zero-valued member. Code fix adds `None = 0`.
dotnet_diagnostic.SST2330.severity = error # A `[Flags]` member is a numeric literal equal to a combination of others (`All = 7`). Code fix writes `A
dotnet_diagnostic.SST2331.severity = none # An enum leaves member values implicit, so their numbers depend on declaration order. Opt-in.
dotnet_diagnostic.SST2332.severity = error # An auto-property's `private set` is only written during construction; make it get-only.
dotnet_diagnostic.SST2333.severity = none # A generic comparison/equality contract is implemented without its non-generic counterpart. Opt-in.
dotnet_diagnostic.SST2334.severity = none # A publicly visible type has no `[DebuggerDisplay]`. Opt-in.
dotnet_diagnostic.SST2335.severity = none # Parts of a partial type disagree on the `static` modifier. Opt-in.

# Correctness
dotnet_diagnostic.SST2400.severity = error # Two arguments name each other's parameters and have been transposed
dotnet_diagnostic.SST2401.severity = error # A catch targets NullReferenceException
dotnet_diagnostic.SST2402.severity = error # An instance constructor assigns a static field of its own type
dotnet_diagnostic.SST2403.severity = error # 'this' escapes from a constructor before the object is fully built
dotnet_diagnostic.SST2404.severity = error # An iterator's argument guard does not run until the first MoveNext
dotnet_diagnostic.SST2405.severity = error # A [DebuggerDisplay] string names a member the type does not have
dotnet_diagnostic.SST2406.severity = error # A loop's stop condition reads only variables the loop never writes
dotnet_diagnostic.SST2407.severity = error # A declared event is never raised
dotnet_diagnostic.SST2408.severity = error # A StringBuilder is filled and never read
dotnet_diagnostic.SST2409.severity = error # A throw constructs a general exception type (Exception/SystemException/ApplicationException)
dotnet_diagnostic.SST2410.severity = error # A created disposable is never disposed and never leaves the method
dotnet_diagnostic.SST2411.severity = error # A for loop declares and tests a counter it never steps
dotnet_diagnostic.SST2412.severity = error # A for loop update moves the counter away from its stop condition
dotnet_diagnostic.SST2413.severity = error # A for loop condition can never be true on the first pass
dotnet_diagnostic.SST2414.severity = error # Two branches of a conditional share the same implementation
dotnet_diagnostic.SST2415.severity = error # A non-short-circuiting & or | evaluates a right operand that does work
dotnet_diagnostic.SST2416.severity = error # A modulus result on a signed type is compared directly to 1
dotnet_diagnostic.SST2417.severity = error # A compound assignment operator is transposed (=+, =-, =!)
dotnet_diagnostic.SST2418.severity = error # The result of an immutable value's method is discarded
dotnet_diagnostic.SST2419.severity = error # A set or collection operation is performed against itself
dotnet_diagnostic.SST2420.severity = error # An IndexOf result is tested with > 0, skipping index 0
dotnet_diagnostic.SST2421.severity = error # A write targets a readonly field of an unconstrained type parameter
dotnet_diagnostic.SST2422.severity = error # A property getter returns a different field than its setter writes
dotnet_diagnostic.SST2423.severity = error # A disposable created in a using statement is returned
dotnet_diagnostic.SST2424.severity = error # An override changes a parameter's default value
dotnet_diagnostic.SST2425.severity = error # An override drops an optional argument on its base call
dotnet_diagnostic.SST2426.severity = error # An override adds or removes params on a parameter
dotnet_diagnostic.SST2427.severity = error # A derived overload widens a parameter and hides the base overload
dotnet_diagnostic.SST2428.severity = error # A static initializer reads a static field declared later
dotnet_diagnostic.SST2429.severity = error # A setter, init, add, or remove accessor never reads value
dotnet_diagnostic.SST2430.severity = error # A serialization callback has the wrong signature
dotnet_diagnostic.SST2431.severity = error # A ToString override can return null
dotnet_diagnostic.SST2432.severity = error # GetType is called on a value that is already a System.Type
dotnet_diagnostic.SST2433.severity = error # A caller-info parameter is not last in the list
dotnet_diagnostic.SST2434.severity = error # An array is assigned through a covariant element type
dotnet_diagnostic.SST2435.severity = error # A non-object base's value-equality Equals is used as a reference-equality fast path
dotnet_diagnostic.SST2436.severity = error # An event is raised with a null sender or null args
dotnet_diagnostic.SST2437.severity = error # A generic type inherits from itself recursively
dotnet_diagnostic.SST2438.severity = error # A catch that discards its exception logs at Error or Critical without it
dotnet_diagnostic.SST2439.severity = error # An exception is passed as a log template argument instead of the exception parameter
dotnet_diagnostic.SST2440.severity = error # Log template arguments are transposed
dotnet_diagnostic.SST2441.severity = error # A log template has an empty or non-identifier placeholder
dotnet_diagnostic.SST2442.severity = error # A log template repeats a named placeholder
dotnet_diagnostic.SST2443.severity = error # An ILogger is injected or created with the wrong category type
dotnet_diagnostic.SST2444.severity = error # A regular expression pattern is invalid
dotnet_diagnostic.SST2445.severity = error # A culture-sensitive custom date or time format is used without an invariant culture
dotnet_diagnostic.SST2446.severity = error # A Stream.ReadAsync result is discarded through ConfigureAwait or a local
dotnet_diagnostic.SST2448.severity = error # A combined or opaque delegate is removed with - or -=, which strips only a contiguous run
dotnet_diagnostic.SST2449.severity = error # A lambda or anonymous-method handler is removed with -=, which never matches it
dotnet_diagnostic.SST2450.severity = error # A Debug.Assert condition performs a side effect that a release build compiles out
dotnet_diagnostic.SST2451.severity = error # Every constructor is private and no member ever creates an instance
dotnet_diagnostic.SST2452.severity = error # A [Pure] method returns void, Task, or ValueTask, so it has no observable result
dotnet_diagnostic.SST2456.severity = error # An override or new field-like event gets its own backing delegate field
dotnet_diagnostic.SST2457.severity = error # An integer Sum wrapped in unchecked still throws on overflow
dotnet_diagnostic.SST2458.severity = error # A bitwise operator is applied to an enum not declared [Flags]
dotnet_diagnostic.SST2459.severity = error # [Optional] on a ref or out parameter advertises an optionality no caller can use
dotnet_diagnostic.SST2460.severity = error # [DefaultValue] on a method or record parameter is inert
dotnet_diagnostic.SST2462.severity = error # A new member is less accessible than the inherited member it hides
dotnet_diagnostic.SST2463.severity = error # A field differs from an inherited accessible field only by case
dotnet_diagnostic.SST2464.severity = error # A mutable class declares a value-equality operator ==, so it is lost as a hash key
dotnet_diagnostic.SST2465.severity = error # A for loop body reassigns the counter or the local its condition tests
dotnet_diagnostic.SST2467.severity = error # A params overload is shadowed by a same-arity overload with a more specific last parameter
dotnet_diagnostic.SST2468.severity = error # A classic partial method is declared but never implemented, so its calls are removed
dotnet_diagnostic.SST2470.severity = error # Two string literals concatenate with no space, fusing a SQL keyword into the next token
dotnet_diagnostic.SST2472.severity = error # A type is exported for a contract it neither implements nor inherits
dotnet_diagnostic.SST2473.severity = error # A shared export part is constructed with new, bypassing the container
dotnet_diagnostic.SST2474.severity = error # A part-creation-policy attribute is applied to a type with no [Export]
dotnet_diagnostic.SST2475.severity = error # An entity's primary key is typed DateTime or DateTimeOffset
dotnet_diagnostic.SST2479.severity = error # A loop variable captured by a callback stored beyond the iteration reads its final value
dotnet_diagnostic.SST2481.severity = error # A GetHashCode override folds the base identity hash into a value hash
dotnet_diagnostic.SST2484.severity = error # A handle read through DangerousGetHandle is not reference-counted
dotnet_diagnostic.SST2485.severity = error # A NotImplementedException is left in shipped code
dotnet_diagnostic.SST2486.severity = error # An assembly is loaded by path or partial name instead of Assembly.Load
dotnet_diagnostic.SST2487.severity = error # A [ConstructorArgument] does not name a constructor parameter
dotnet_diagnostic.SST2488.severity = error # An exception is logged and rethrown, duplicating the record
dotnet_diagnostic.SST2489.severity = error # A relational comparison is decided by the operand's type rather than its value
dotnet_diagnostic.SST2490.severity = error # Adjacent try statements with identical handling should be merged
dotnet_diagnostic.SST2491.severity = error # A non-`async` method returns an awaitable from inside `using`/`try-finally`/`lock`, so the resource is torn down before the task completes. Code fix makes it `async`.
dotnet_diagnostic.SST2492.severity = error # A null-guard throws on a parameter the signature declares may be null.
dotnet_diagnostic.SST2493.severity = error # `== null`/`!= null` on an unconstrained generic `T`. Code fix uses `is null`/`is not null`.
dotnet_diagnostic.SST2494.severity = error # A `??` whose left operand is a constant null, so the right is always taken. Code fix folds it.
dotnet_diagnostic.SST2495.severity = error # A `[Flags]` combination includes an operand whose bits another already covers. Code fix removes it.
dotnet_diagnostic.SST2496.severity = error # An explicit `Dispose`/`Close` on a resource an enclosing `using` already disposes. Code fix removes it. Info.

# Testing
dotnet_diagnostic.SST2500.severity = error # A test method contains no assertion and no expected-exception check
dotnet_diagnostic.SST2501.severity = error # An equality or identity assertion compares an expression with itself
dotnet_diagnostic.SST2502.severity = error # An equality assertion passes the constant as actual and the computed value as expected
dotnet_diagnostic.SST2503.severity = error # An equality assertion compares a value against a boolean literal
dotnet_diagnostic.SST2504.severity = error # A test fixture declares and inherits no test method
dotnet_diagnostic.SST2505.severity = error # A test method declares parameters but no data source
dotnet_diagnostic.SST2506.severity = error # A test method calls Thread.Sleep
dotnet_diagnostic.SST2507.severity = error # A test method declares its expected failure with an expected-exception attribute
dotnet_diagnostic.SST2508.severity = error # A fluent assertion is started but never completed
dotnet_diagnostic.SST2509.severity = error # A test method has a shape the runner cannot execute

# Logging
dotnet_diagnostic.SST2600.severity = error # Application output is written through legacy Trace instead of a structured logger
dotnet_diagnostic.SST2601.severity = error # A logger field or property does not follow the logger naming convention

# Frameworks
dotnet_diagnostic.SST2700.severity = error # An MVC route template contains a backslash; route segments are separated by `/`, so the route is unreachable. Code fix replaces `\` with `/`.
dotnet_diagnostic.SST2701.severity = error # A `[JSInvokable]` method is not public, so JavaScript interop cannot call it. Code fix makes it public.
dotnet_diagnostic.SST2702.severity = error # A `[SupplyParameterFromQuery]` property has a type the framework cannot bind from the query string, which throws at runtime.
dotnet_diagnostic.SST2703.severity = error # A routable component's route constraint (`{id:int}`) disagrees with the matching `[Parameter]` CLR type, so the route silently fails to match.
dotnet_diagnostic.SST2704.severity = error # A public action on an `[ApiController]` declares no HTTP-verb attribute, so it answers every verb and can make routing ambiguous.
dotnet_diagnostic.SST2705.severity = none # A bound model member is a non-nullable value type with no required marker, so a request that omits it binds the default with no error. Opt-in.
dotnet_diagnostic.SST2706.severity = error # A Windows Forms entry point carries neither `[STAThread]` nor `[MTAThread]`; without STA, clipboard, drag-and-drop, and common dialogs misbehave. Code fix adds `[STAThread]`.
dotnet_diagnostic.SST2707.severity = none # A fire-and-forget `Task.Run` in a controller captures the request's `HttpContext`, which is disposed when the request ends, so the background work throws `ObjectDisposedException`. Opt-in.
dotnet_diagnostic.SST2708.severity = error # A component subscribes to an event in a lifecycle method but never unsubscribes, so the event source keeps the component alive — a per-session leak on a Server circuit.
dotnet_diagnostic.SST2709.severity = error # `StateHasChanged` is called while the component is being disposed, which the renderer no longer supports and throws.
dotnet_diagnostic.SST2710.severity = error # `StateHasChanged` is called directly from a timer callback, off the renderer's dispatcher; marshal it with `InvokeAsync(StateHasChanged)`.
dotnet_diagnostic.SST2711.severity = error # A synchronous component lifecycle method is overridden as `async void`, which the framework never awaits; override the `…Async` twin returning `Task`. Code fix rewrites the signature.
dotnet_diagnostic.SST2712.severity = error # An `[Inject]`/`[CascadingParameter]` property has no setter, so the framework's reflection-based binding leaves it null. Code fix adds a setter.
dotnet_diagnostic.SST2713.severity = error # A `DotNetObjectReference.Create(this)` is passed inline and never stored, so nothing can dispose it and it leaks on the JavaScript side.

###################
# PerformanceSharp Analyzers (PSH)
###################
performancesharp.avoid_linq_on_hot_path = true
# performancesharp.empty_string_style = pattern            # PSH1204 (pattern | length | is_null_or_empty; the last two are only offered where the string is provably not null)
# performancesharp.excluded_properties = Items, Keys       # PSH1017 (comma-separated; properties allowed to copy on read)
# performancesharp.include_public = false                  # PSH1411 (set true in an app to seal public types too; a break in a library)
dotnet_diagnostic.PSH1000.severity = error # Anonymous functions without captures should be static
dotnet_diagnostic.PSH1001.severity = error # Avoid allocating zero-length arrays (fix prefers [] on C# 12+, else Array.Empty<T>())
dotnet_diagnostic.PSH1002.severity = error # Empty finalizers should be removed
dotnet_diagnostic.PSH1003.severity = error # 'in' parameters should use readonly structs
dotnet_diagnostic.PSH1004.severity = error # Constant arrays passed as arguments should be hoisted
dotnet_diagnostic.PSH1005.severity = error # Structs should define equality members to avoid boxing comparisons
dotnet_diagnostic.PSH1006.severity = error # ConcurrentDictionary factories should use the lambda argument
dotnet_diagnostic.PSH1007.severity = error # Pass large readonly structs by 'in' reference (size threshold + exclusions configurable)
dotnet_diagnostic.PSH1008.severity = error # GC.SuppressFinalize does nothing for sealed finalizer-free types
dotnet_diagnostic.PSH1009.severity = error # Bound variable-length stackalloc with a constant guard
dotnet_diagnostic.PSH1010.severity = error # Clear reference-typed arrays when returning them to the pool
dotnet_diagnostic.PSH1011.severity = error # Pass state to callbacks through the state-taking overload
dotnet_diagnostic.PSH1012.severity = error # Compare type parameter values with EqualityComparer<T>.Default
dotnet_diagnostic.PSH1013.severity = error # Expose constant UTF-8 data as a ReadOnlySpan<byte> property
dotnet_diagnostic.PSH1014.severity = error # Declare immutable structs as readonly
dotnet_diagnostic.PSH1015.severity = error # Avoid casting value types through object
dotnet_diagnostic.PSH1016.severity = error # Test enum flags with bitwise operators instead of Enum.HasFlag
dotnet_diagnostic.PSH1017.severity = error # A property allocates a copy of a collection on every read (excludable via performancesharp.PSH1017.excluded_properties)
dotnet_diagnostic.PSH1018.severity = error # A hand-written array is passed to a params parameter
dotnet_diagnostic.PSH1019.severity = error # The range indexer on an array allocates a copy; slice with AsSpan/AsMemory
dotnet_diagnostic.PSH1020.severity = error # Prefer a jagged array over a multidimensional one
dotnet_diagnostic.PSH1021.severity = error # An explicit GC.Collect or GC.WaitForPendingFinalizers forces collection the runtime tunes itself
dotnet_diagnostic.PSH1022.severity = error # A parameterless `new EventArgs()` allocates where the shared `EventArgs.Empty` singleton would serve. Code fix uses the singleton.
dotnet_diagnostic.PSH1100.severity = error # Hot-path code should avoid System.Linq.Enumerable calls
dotnet_diagnostic.PSH1101.severity = none # LINQ terminal predicate simplification is reserved for test code; production code should avoid LINQ on hot paths
dotnet_diagnostic.PSH1102.severity = none # LINQ type-filter simplification is reserved for test code; production code should avoid LINQ on hot paths
dotnet_diagnostic.PSH1103.severity = error # Prefer the collection's own count over enumerating
dotnet_diagnostic.PSH1104.severity = error # Use TryGetValue instead of ContainsKey followed by an indexer read
dotnet_diagnostic.PSH1105.severity = error # Avoid double lookups on dictionaries and sets
dotnet_diagnostic.PSH1106.severity = error # Index collections directly instead of using LINQ element access
dotnet_diagnostic.PSH1107.severity = error # Filter sequences before sorting them
dotnet_diagnostic.PSH1108.severity = error # Chain secondary sorts with ThenBy
dotnet_diagnostic.PSH1109.severity = error # Merge consecutive Where calls
dotnet_diagnostic.PSH1110.severity = error # Use the collection's own predicate methods over LINQ
dotnet_diagnostic.PSH1111.severity = error # Use Contains for membership tests
dotnet_diagnostic.PSH1112.severity = error # Seed the collection through its constructor (fix honors performancesharp.prefer_collection_expressions)
dotnet_diagnostic.PSH1113.severity = error # Sort naturally instead of ordering by the element itself
dotnet_diagnostic.PSH1114.severity = none # Freeze static lookup collections that are never mutated. Opt-in.
dotnet_diagnostic.PSH1115.severity = error # Insert-if-absent should probe the dictionary once
dotnet_diagnostic.PSH1116.severity = error # Probe string-keyed collections with a span through GetAlternateLookup
dotnet_diagnostic.PSH1117.severity = error # Ask the collection whether it is empty
dotnet_diagnostic.PSH1118.severity = error # Take the extreme element with Min/Max/MinBy/MaxBy instead of sorting
dotnet_diagnostic.PSH1119.severity = error # Check for elements with Any instead of counting them all
dotnet_diagnostic.PSH1120.severity = error # Do not materialize a sequence with ToList/ToArray just to enumerate it
dotnet_diagnostic.PSH1122.severity = error # Read a sorted set's extreme through its Min/Max property, not the LINQ extension
dotnet_diagnostic.PSH1124.severity = error # Read a linked list's end through its First/Last property, not the LINQ extension
dotnet_diagnostic.PSH1125.severity = error # Do not enumerate the same lazy sequence twice
dotnet_diagnostic.PSH1126.severity = error # Ask whether an async sequence has elements instead of counting them
dotnet_diagnostic.PSH1127.severity = error # Clear an array instead of filling it with its default
dotnet_diagnostic.PSH1200.severity = error # Compare strings without allocating case-converted copies
dotnet_diagnostic.PSH1201.severity = error # Use the char overload for single-character strings
dotnet_diagnostic.PSH1202.severity = error # Append characters as char, not single-character strings
dotnet_diagnostic.PSH1203.severity = error # Let StringBuilder do the formatting work
dotnet_diagnostic.PSH1204.severity = error # Test for empty strings by length
dotnet_diagnostic.PSH1205.severity = error # Remove interpolation that does no work
dotnet_diagnostic.PSH1206.severity = error # Do not build strings by concatenation in loops
dotnet_diagnostic.PSH1207.severity = error # Specify StringComparison for culture-sensitive string operations
dotnet_diagnostic.PSH1208.severity = error # Encode constant strings with u8 literals
dotnet_diagnostic.PSH1209.severity = error # Build transformed strings with string.Create
dotnet_diagnostic.PSH1210.severity = error # Compare UTF-8 bytes without decoding them
dotnet_diagnostic.PSH1211.severity = error # Pass values directly instead of ToString results
dotnet_diagnostic.PSH1212.severity = error # Slice with AsSpan when the call accepts a span
dotnet_diagnostic.PSH1213.severity = error # Probe repeated character sets through SearchValues
dotnet_diagnostic.PSH1214.severity = error # Append the parts of a concatenation separately, not the concatenated whole
dotnet_diagnostic.PSH1215.severity = error # Use string.Concat instead of string.Join with an empty separator
dotnet_diagnostic.PSH1216.severity = error # Use string.Equals instead of comparing string.Compare to zero
dotnet_diagnostic.PSH1217.severity = error # A sequence is copied to an array just to be read straight back
dotnet_diagnostic.PSH1218.severity = error # A substring is allocated only to search it; slice with AsSpan instead
dotnet_diagnostic.PSH1219.severity = error # Ask whether a string is blank without trimming it
dotnet_diagnostic.PSH1220.severity = error # A length argument spells out the run that reaches the end anyway
dotnet_diagnostic.PSH1221.severity = error # An IndexOf compared to 0 scans the whole string to answer a prefix test
dotnet_diagnostic.PSH1222.severity = error # Concatenate slices without materializing them
dotnet_diagnostic.PSH1223.severity = error # A reused composite format string is re-parsed on every call
dotnet_diagnostic.PSH1224.severity = error # Convert bytes to hex in one call, not by building the string twice
dotnet_diagnostic.PSH1225.severity = error # Decode bytes to a string in one call, without a throwaway char[]
dotnet_diagnostic.PSH1226.severity = error # A string's `ToCharArray()` result is only iterated, allocating a throwaway `char[]`; iterate the string directly. Code fix drops the copy.
dotnet_diagnostic.PSH1227.severity = error # A cheaper equivalent exists — `string.CompareOrdinal` over `Compare(…, Ordinal)`, `Debug.Fail` over `Debug.Assert(false, …)`. Info. Code fix rewrites the call.
dotnet_diagnostic.PSH1300.severity = error # Use System.Threading.Lock for a dedicated lock object
dotnet_diagnostic.PSH1301.severity = error # Do not wrap a single task in WhenAll or WaitAll
dotnet_diagnostic.PSH1302.severity = error # TaskCompletionSource should run continuations asynchronously
dotnet_diagnostic.PSH1303.severity = error # Do not block an async method with Thread.Sleep
dotnet_diagnostic.PSH1304.severity = error # Use PeriodicTimer instead of pacing a loop with Task.Delay
dotnet_diagnostic.PSH1305.severity = error # Enumerate a ConcurrentDictionary directly, not its Keys/Values snapshots
dotnet_diagnostic.PSH1306.severity = none # Guard one-time execution with an interlocked latch. Opt-in.
dotnet_diagnostic.PSH1307.severity = error # Access interlocked fields with Volatile
dotnet_diagnostic.PSH1308.severity = error # Return the completed task instead of Task.FromResult
dotnet_diagnostic.PSH1309.severity = none # Register cancellation callbacks without flowing the execution context. Opt-in.
dotnet_diagnostic.PSH1310.severity = error # Dispose IAsyncDisposable resources with await using in async code
dotnet_diagnostic.PSH1311.severity = error # Remove a pass-through async state machine and return the task directly
dotnet_diagnostic.PSH1312.severity = error # Return a completed task instead of null
dotnet_diagnostic.PSH1313.severity = error # A synchronous call where an async overload fits
dotnet_diagnostic.PSH1314.severity = error # Read and write streams through the memory-based overloads
dotnet_diagnostic.PSH1315.severity = error # A blocking wait on an awaitable that may not be done
dotnet_diagnostic.PSH1316.severity = error # A ValueTask is awaited in a loop or awaited after being copied
dotnet_diagnostic.PSH1400.severity = error # Use the static HashData method for one-shot hashing
dotnet_diagnostic.PSH1401.severity = error # Attribute types should be sealed
dotnet_diagnostic.PSH1402.severity = error # Use const for compile-time constants
dotnet_diagnostic.PSH1403.severity = error # Do not initialize fields to their default value
dotnet_diagnostic.PSH1404.severity = error # Get the assembly from typeof instead of a stack walk
dotnet_diagnostic.PSH1405.severity = error # Use the direct Environment APIs
dotnet_diagnostic.PSH1406.severity = error # Ask Regex for the answer directly
dotnet_diagnostic.PSH1407.severity = error # Query the dictionary, not its Keys view
dotnet_diagnostic.PSH1408.severity = error # Measure elapsed time with Stopwatch timestamps
dotnet_diagnostic.PSH1409.severity = error # Use the built-in throw helpers for argument guards
dotnet_diagnostic.PSH1410.severity = none # Mark trivial forwarders for aggressive inlining. Opt-in.
dotnet_diagnostic.PSH1411.severity = error # Seal non-public types nothing derives from so the JIT can devirtualize
dotnet_diagnostic.PSH1412.severity = error # Use Random.Shared instead of allocating a Random
dotnet_diagnostic.PSH1413.severity = error # Read the Unix epoch from the framework, not a hand-built DateTime
dotnet_diagnostic.PSH1414.severity = error # Mark members that do not touch instance state as static
dotnet_diagnostic.PSH1415.severity = error # Hold the concrete type when the concrete type is what you have
dotnet_diagnostic.PSH1416.severity = error # Cache the serializer options instead of building them per call
dotnet_diagnostic.PSH1417.severity = error # Do not compute an expensive argument for an assertion
dotnet_diagnostic.PSH1418.severity = error # An HttpClient is constructed on every call
dotnet_diagnostic.PSH1419.severity = error # A time-zone is resolved with a platform-specific id instead of the cross-platform API
dotnet_diagnostic.PSH1420.severity = error # A shareable client held in an instance field of an Azure Functions worker class is rebuilt on every invocation, leaking sockets and connections; share a static/singleton client or inject `IHttpClientFactory`.

# ASP.NET Core - inert in this repo (no route handlers or middleware), enabled so the set stays complete
dotnet_diagnostic.PSH1500.severity = error # A minimal API handler returns Results instead of TypedResults, boxing the result
dotnet_diagnostic.PSH1501.severity = error # Middleware uses the legacy nested-delegate Use overload, allocating a per-request closure
dotnet_diagnostic.PSH1502.severity = error # A route handler returns a deferred sequence the serializer enumerates on the request thread
dotnet_diagnostic.PSH1503.severity = error # Response caching is used where server-side output caching applies
dotnet_diagnostic.PSH1505.severity = error # Exceptions are handled in an MVC exception filter instead of an IExceptionHandler
dotnet_diagnostic.PSH1506.severity = error # The HTTP request or response body is read or written synchronously (`ReadToEnd`, `Body.Read`, `Body.Write`), which blocks a thread on Kestrel and buffers the whole payload; use the async overload. Code fix awaits it when the method is already async.

# Blazor
dotnet_diagnostic.PSH1600.severity = error # A delegate captured per iteration inside a component render loop reallocates on every render (measured ~128 B per row per render) and churns the diff; hoist it to a cached delegate or a precomputed per-item model.
dotnet_diagnostic.PSH1601.severity = error # A JavaScript-interop call is issued once per loop iteration; on Interactive Server each is a separate SignalR round-trip. Batch into a single call over the collection.
dotnet_diagnostic.PSH1602.severity = error # `StateHasChanged` is called unconditionally in `OnAfterRender`/`OnAfterRenderAsync`, scheduling another render every time — a runaway loop. Guard it with `firstRender` or a state flag.
dotnet_diagnostic.PSH1603.severity = error # A non-delegate allocation is used as a component-parameter value inside a render loop, allocating per item and forcing the child to re-render each pass. Sibling of PSH1600.

###################
# SecuritySharp Analyzers (SES)
###################
# Every rule is raised to error, including the three that ship at suggestion (SES1403, SES1506,
# SES1605). Security rules only ever suggest an API they can resolve in the compilation and report
# local shapes only - there is no interprocedural taint tracking, so the taint-flow CA rules stay on.
# securitysharp.SES1003.iterations = 100000                # minimum accepted PBKDF2 iteration count
# securitysharp.SES1403.maxdepth = 64                      # highest accepted System.Text.Json MaxDepth

# Cryptography
dotnet_diagnostic.SES1001.severity = error # AEAD encryption must not use a constant or reused nonce
dotnet_diagnostic.SES1002.severity = error # Password-based key derivation must not use a constant or predictable salt
dotnet_diagnostic.SES1003.severity = error # Password-based key derivation must use a sufficient iteration count
dotnet_diagnostic.SES1004.severity = error # A secret must not be produced from Guid.NewGuid()
dotnet_diagnostic.SES1005.severity = error # Compare secret values in constant time
dotnet_diagnostic.SES1006.severity = error # A Data Protection key ring is persisted without a ProtectKeysWith call, so keys sit unencrypted at rest
dotnet_diagnostic.SES1007.severity = error # A cryptographic primitive is implemented by hand instead of using a vetted platform algorithm
dotnet_diagnostic.SES1008.severity = error # An XML signature is verified with the no-key CheckSignature overload, trusting the document's own KeyInfo
dotnet_diagnostic.SES1009.severity = error # A password is stored without a slow, salted key-derivation function

# Transport
dotnet_diagnostic.SES1102.severity = error # Do not accept any server certificate
dotnet_diagnostic.SES1104.severity = error # Certificate-chain validation must not be deliberately weakened
dotnet_diagnostic.SES1105.severity = error # Bearer and OpenID Connect metadata must not be retrieved over plain HTTP outside development
dotnet_diagnostic.SES1106.severity = error # Do not send HttpClient requests to a cleartext http URL
dotnet_diagnostic.SES1107.severity = error # A SQL connection string weakens transport security via TrustServerCertificate or a disabled Encrypt
dotnet_diagnostic.SES1108.severity = error # A custom server-certificate validation callback unconditionally returns true, so any certificate is trusted

# Secrets
dotnet_diagnostic.SES1201.severity = error # Do not hard-code secrets in source
dotnet_diagnostic.SES1202.severity = error # Do not hard-code a credential value
dotnet_diagnostic.SES1203.severity = error # A connection string names a user but supplies an empty or missing password

# Injection
dotnet_diagnostic.SES1301.severity = error # Do not build a process command line from non-constant string parts
dotnet_diagnostic.SES1302.severity = error # A shell-executed process must not use a non-constant FileName
dotnet_diagnostic.SES1303.severity = error # Regular-expression pattern must not be built from non-constant data
dotnet_diagnostic.SES1304.severity = error # An archive entry name must not build a write path without a containment check
dotnet_diagnostic.SES1305.severity = error # Do not build a storage path from an uploaded file name
dotnet_diagnostic.SES1306.severity = error # Do not compile or execute non-constant C# via the scripting API
dotnet_diagnostic.SES1307.severity = error # Path.GetTempFileName creates a predictable, world-readable temporary file
dotnet_diagnostic.SES1308.severity = error # A file or directory is created group- or world-writable
dotnet_diagnostic.SES1309.severity = error # An XSLT stylesheet is loaded with embedded script enabled
dotnet_diagnostic.SES1310.severity = error # A directory bind is performed without authenticating

# Serialization
dotnet_diagnostic.SES1401.severity = error # A type resolved from non-constant data must not be instantiated or deserialized
dotnet_diagnostic.SES1402.severity = error # Do not load an assembly from raw bytes or a non-constant location
dotnet_diagnostic.SES1403.severity = error # JSON deserialization depth limit must stay within a safe ceiling
dotnet_diagnostic.SES1404.severity = error # A type is instantiated by name from a non-constant Activator typeName
dotnet_diagnostic.SES1405.severity = error # MessagePack typeless deserialization reconstructs whatever type the payload names
dotnet_diagnostic.SES1406.severity = warning # Reflection must not reach non-public members via BindingFlags.NonPublic (opt-in; replaces S3011)

# Web hardening
dotnet_diagnostic.SES1501.severity = error # A CORS policy must not allow credentials together with any origin
dotnet_diagnostic.SES1502.severity = error # A CORS origin predicate must not unconditionally allow every origin
dotnet_diagnostic.SES1503.severity = error # JWT signature verification must not be disabled on TokenValidationParameters
dotnet_diagnostic.SES1504.severity = error # A cookie with SameSite=None must be marked Secure
dotnet_diagnostic.SES1505.severity = error # The request body size limit must not be removed
dotnet_diagnostic.SES1506.severity = error # The developer exception page must be guarded by a development-environment check
dotnet_diagnostic.SES1507.severity = error # AllowAnonymous and Authorize on the same declaration conflict
dotnet_diagnostic.SES1508.severity = error # A validation method must not fail open by returning success from a catch
dotnet_diagnostic.SES1509.severity = error # A backtracking-prone constant regex runs without a match timeout or NonBacktracking
dotnet_diagnostic.SES1510.severity = error # A controller redirects to a non-constant URL, allowing an open redirect
dotnet_diagnostic.SES1511.severity = error # The forwarded-headers trust boundary is cleared, letting proxies spoof the client IP
dotnet_diagnostic.SES1512.severity = error # Sensitive framework diagnostics are enabled without a development-environment guard
dotnet_diagnostic.SES1513.severity = error # An AuthorizeAsync result is discarded, so the guarded operation runs regardless
dotnet_diagnostic.SES1514.severity = error # OpenID Connect protections (PKCE, state, nonce) are disabled
dotnet_diagnostic.SES1515.severity = error # A Content-Security-Policy value disables its own protection

# AI trust boundaries
dotnet_diagnostic.SES1601.severity = error # An LLM system prompt must be a constant, trusted template
dotnet_diagnostic.SES1602.severity = error # Do not route AI model output into a process, file, or raw SQL sink
dotnet_diagnostic.SES1603.severity = error # An AI tool declared read-only or non-destructive must not call a state-changing API
dotnet_diagnostic.SES1604.severity = error # Prompt-template input encoding must not be disabled
dotnet_diagnostic.SES1605.severity = error # AI instrumentation must not enable sensitive-data capture
dotnet_diagnostic.SES1606.severity = error # Do not fetch model weights over cleartext HTTP

# Web UI trust boundaries
dotnet_diagnostic.SES1701.severity = error # Raw HTML is rendered from a non-constant value (`MarkupString`/`AddMarkupContent`), bypassing automatic encoding — an XSS risk. Sanitizer allow-list via `securitysharp.SES1701.sanitizers`.
dotnet_diagnostic.SES1702.severity = error # A JavaScript-interop call targets a script-evaluation primitive (`eval`, `Function`, `document.write`), turning interop into a script-injection channel.
dotnet_diagnostic.SES1703.severity = error # `[Authorize]` on a non-routable component enforces nothing — authorization runs as a routing concern. Exempt types via `securitysharp.SES1703.exempt_types`.
dotnet_diagnostic.SES1704.severity = error # `IHttpContextAccessor` or a cascading `HttpContext` is used in an interactively-rendered component, where it is null or frozen at circuit start.
dotnet_diagnostic.SES1705.severity = error # `NavigationManager.NavigateTo` is called with a target that is not a verified relative URL — an open-redirect risk. Validator allow-list via `securitysharp.SES1705.validators`.
dotnet_diagnostic.SES1706.severity = error # An uploaded file is read with an unbounded or client-chosen size limit, letting an attacker fill server memory. Threshold via `securitysharp.SES1706.max_bytes`.
dotnet_diagnostic.SES1707.severity = error # A secret-shaped literal appears in code reachable as WebAssembly, which downloads to the browser in full — guaranteed disclosure.
dotnet_diagnostic.SES1708.severity = error # `CircuitOptions.DetailedErrors` is enabled, shipping server exception detail to every connected client.
dotnet_diagnostic.SES1709.severity = error # `SerializeAllClaims` serializes every claim into client-readable WebAssembly authentication state, exposing internal ids, tokens, and PII.
dotnet_diagnostic.SES1710.severity = error # Antiforgery validation is disabled on a form (`[RequireAntiforgeryToken(required: false)]`), removing CSRF protection.


###################
# Microsoft.CodeAnalysis.PublicApiAnalyzers (RS)
###################
# Public API surface tracking
dotnet_diagnostic.RS0016.severity = error # public symbol missing from the PublicAPI baseline
dotnet_diagnostic.RS0017.severity = error # PublicAPI baseline entry no longer in source

###################
# Microsoft.NET.ILLink.Analyzers (IL)
###################
# Trimming
# See: https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-warnings/
dotnet_diagnostic.IL2001.severity = error # Type in UnreferencedCode attribute doesn't have matching RequiresUnreferencedCode
dotnet_diagnostic.IL2002.severity = error # Method with RequiresUnreferencedCode called from code without that attribute
dotnet_diagnostic.IL2003.severity = error # RequiresUnreferencedCode attribute is only supported on methods
dotnet_diagnostic.IL2004.severity = error # Incorrect RequiresUnreferencedCode signature
dotnet_diagnostic.IL2005.severity = error # Could not resolve dependency assembly
dotnet_diagnostic.IL2007.severity = error # Could not process embedded resource
dotnet_diagnostic.IL2008.severity = error # Could not find type in assembly
dotnet_diagnostic.IL2009.severity = error # Could not find method in type
dotnet_diagnostic.IL2010.severity = error # Invalid value for PreserveDependencyAttribute
dotnet_diagnostic.IL2011.severity = error # Unknown body modification
dotnet_diagnostic.IL2012.severity = error # Could not find field in type
dotnet_diagnostic.IL2013.severity = error # Substitution file contains invalid XML
dotnet_diagnostic.IL2014.severity = error # Missing substitution file
dotnet_diagnostic.IL2015.severity = error # Invalid XML encountered in substitution file
dotnet_diagnostic.IL2016.severity = error # Could not find type from substitution XML
dotnet_diagnostic.IL2017.severity = error # Could not find method in type specified in substitution XML
dotnet_diagnostic.IL2018.severity = error # Could not find field in type specified in substitution XML
dotnet_diagnostic.IL2019.severity = error # Could not find interface implementation in type
dotnet_diagnostic.IL2022.severity = error # Type in DynamicallyAccessedMembers attribute doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2023.severity = error # Method returning DynamicallyAccessedMembers annotated type requires the same annotation
dotnet_diagnostic.IL2024.severity = error # Multiple DynamicallyAccessedMembers annotations on a member are not supported
dotnet_diagnostic.IL2025.severity = error # Duplicate preserve attribute
dotnet_diagnostic.IL2026.severity = error # Using member annotated with RequiresUnreferencedCode
dotnet_diagnostic.IL2027.severity = error # RequiresUnreferencedCodeAttribute is only supported on methods and constructors
dotnet_diagnostic.IL2028.severity = error # Invalid RequiresUnreferencedCode attribute usage
dotnet_diagnostic.IL2029.severity = error # RequiresUnreferencedCode attribute on type is not supported
dotnet_diagnostic.IL2030.severity = error # Dynamic invocation of method requiring unreferenced code is not safe
dotnet_diagnostic.IL2031.severity = error # Could not resolve dependency assembly from embedded resource
dotnet_diagnostic.IL2032.severity = error # Error reading debug symbols
dotnet_diagnostic.IL2033.severity = error # Trying to modify a sealed type
dotnet_diagnostic.IL2034.severity = error # Value passed to the implicit 'this' parameter does not satisfy 'DynamicallyAccessedMembersAttribute' requirements
dotnet_diagnostic.IL2035.severity = error # Unrecognized value passed to the parameter of method with 'DynamicallyAccessedMembersAttribute' requirements
dotnet_diagnostic.IL2036.severity = error # Interface implementation has different DynamicallyAccessedMembers annotations than interface
dotnet_diagnostic.IL2037.severity = error # BaseType annotation doesn't match
dotnet_diagnostic.IL2038.severity = error # Derived type doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2039.severity = error # Implementation method doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2040.severity = error # Interface member doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2041.severity = error # GetType call on DynamicallyAccessedMembers annotated generic parameter
dotnet_diagnostic.IL2042.severity = error # The DynamicallyAccessedMembersAttribute value used in a custom attribute is not compatible
dotnet_diagnostic.IL2043.severity = error # DynamicallyAccessedMembersAttribute on property conflicts with base property
dotnet_diagnostic.IL2044.severity = error # DynamicallyAccessedMembersAttribute on event conflicts with base event
dotnet_diagnostic.IL2045.severity = error # Field type doesn't satisfy 'DynamicallyAccessedMembersAttribute' requirements
dotnet_diagnostic.IL2046.severity = error # Trimmer couldn't find PreserveBaseOverridesAttribute on a method
dotnet_diagnostic.IL2048.severity = error # Internal attribute couldn't be removed
dotnet_diagnostic.IL2049.severity = error # Could not process data format message
dotnet_diagnostic.IL2050.severity = error # Correctness of COM interop cannot be guaranteed after trimming
dotnet_diagnostic.IL2051.severity = error # COM related type is trimmed
dotnet_diagnostic.IL2052.severity = error # Resolving member reference for P/Invoke into type that is trimmed
dotnet_diagnostic.IL2053.severity = error # Target method is trimmed
dotnet_diagnostic.IL2054.severity = error # Generic constraint type is annotated with DynamicallyAccessedMembersAttribute which requires unreferenced code
dotnet_diagnostic.IL2055.severity = error # Type implements COM visible type but has no GUID
dotnet_diagnostic.IL2056.severity = error # Generic parameter with DynamicallyAccessedMembers annotation is not publicly visible
dotnet_diagnostic.IL2057.severity = error # Unrecognized value passed to the parameter of method with DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2058.severity = error # Parameter types of method doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2059.severity = error # Unrecognized reflection pattern
dotnet_diagnostic.IL2060.severity = error # Unrecognized value passed to parameter with DynamicallyAccessedMembersAttribute
dotnet_diagnostic.IL2061.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2062.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2063.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2064.severity = error # Value assigned to field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2065.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2066.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2067.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2068.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2069.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2070.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2071.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2072.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2073.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2074.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2075.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2076.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2077.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2078.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2079.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2080.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2081.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2082.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2083.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2084.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2085.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2087.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2088.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2089.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2090.severity = error # Value passed to implicit this parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2091.severity = error # Target generic argument doesn't satisfy 'DynamicallyAccessedMembersAttribute' requirements
dotnet_diagnostic.IL2092.severity = error # Value passed to generic parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2093.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2094.severity = error # DynamicallyAccessedMembers on 'this' parameter doesn't match overridden member
dotnet_diagnostic.IL2095.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2096.severity = error # Calling method on statically typed generic instance requires unreferenced code
dotnet_diagnostic.IL2097.severity = error # Value passed to parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2098.severity = error # Value stored in field doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2099.severity = error # Value returned from method doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2100.severity = error # XML stream doesn't conform to the schema
dotnet_diagnostic.IL2101.severity = error # Embedded XML in assembly couldn't be loaded
dotnet_diagnostic.IL2102.severity = error # Invalid warning number passed to UnconditionalSuppressMessage
dotnet_diagnostic.IL2103.severity = error # Value passed to the 'propertyAccessExpression' parameter doesn't satisfy DynamicallyAccessedMembersAttribute requirements
dotnet_diagnostic.IL2104.severity = error # Assembly that was specified through a custom step
dotnet_diagnostic.IL2105.severity = error # Type from a custom step that couldn't be loaded
dotnet_diagnostic.IL2106.severity = error # Method from a custom step that couldn't be loaded
dotnet_diagnostic.IL2107.severity = error # Methods in types that derive from RemotingClientProxy cannot be statically determined
dotnet_diagnostic.IL2108.severity = error # Invalid scope for UnconditionalSuppressMessage
dotnet_diagnostic.IL2109.severity = error # Method doesn't have matching DynamicallyAccessedMembers annotation
dotnet_diagnostic.IL2110.severity = error # Invalid member name in UnconditionalSuppressMessage
dotnet_diagnostic.IL2111.severity = error # Method with parameters or return value with DynamicallyAccessedMembersAttribute is not supported
dotnet_diagnostic.IL2112.severity = error # Reflection call to method with DynamicallyAccessedMembersAttribute requirements cannot be statically analyzed
dotnet_diagnostic.IL2113.severity = error # DynamicallyAccessedMembers on type references Type.MakeGenericType with different requirements
dotnet_diagnostic.IL2114.severity = error # DynamicallyAccessedMembers mismatch on signature types
dotnet_diagnostic.IL2115.severity = error # DynamicallyAccessedMembers on type or base types references member which requires unreferenced code
dotnet_diagnostic.IL2116.severity = error # DynamicallyAccessedMembers on parameter types doesn't match overridden parameter
dotnet_diagnostic.IL2117.severity = error # Methods with DynamicallyAccessedMembersAttribute annotations cannot be replaced
dotnet_diagnostic.IL2122.severity = error # Reflection call to method with UnreferencedCode attribute cannot be statically analyzed
dotnet_diagnostic.IL2123.severity = error # DynamicallyAccessedMembers on method or parameter doesn't match overridden member

# Native AOT
# See: https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/warnings/
dotnet_diagnostic.IL3050.severity = error # Using member annotated with RequiresDynamicCode
dotnet_diagnostic.IL3051.severity = error # RequiresDynamicCode attribute is only supported on methods and constructors
dotnet_diagnostic.IL3052.severity = error # RequiresDynamicCode attribute on type is not supported
dotnet_diagnostic.IL3053.severity = error # Assembly has RequiresDynamicCode attribute
dotnet_diagnostic.IL3054.severity = error # Generic expansion in type requires dynamic code
dotnet_diagnostic.IL3055.severity = error # MakeGenericType on non-supported type requires dynamic code
dotnet_diagnostic.IL3056.severity = error # MakeGenericMethod on non-supported method requires dynamic code
dotnet_diagnostic.IL3057.severity = error # Reflection access to generic parameter requires dynamic code

###################
# SonarAnalyzer.CSharp (S)
###################
# Repository suppressions
dotnet_diagnostic.S1075.severity = none # Hardcoded URI — canonical SourceLink hosts are the point
dotnet_diagnostic.S2436.severity = none # Too many generic parameters — needed for the projector overload
dotnet_diagnostic.S4036.severity = none # PATH-relative process spawn — benchmark only, trusted env
dotnet_diagnostic.S8969.severity = none # Nullability inference is inconsistent across the repository's target frameworks

# Blocker bugs
dotnet_diagnostic.S1048.severity = none # Finalizers should not throw exceptions — covered by SST1485
dotnet_diagnostic.S2190.severity = none # Loops and recursions should not be infinite
dotnet_diagnostic.S2275.severity = none # Composite format strings should not lead to unexpected behavior at runtime - DUPLICATE CA2241
dotnet_diagnostic.S2857.severity = none # SQL keywords should be delimited by whitespace — covered by SST2470
dotnet_diagnostic.S2930.severity = none # "IDisposables" should be disposed — covered by SST2410
dotnet_diagnostic.S2931.severity = none # Classes with "IDisposable" members should implement "IDisposable" — covered by SST2315
dotnet_diagnostic.S3464.severity = none # Type inheritance should not be recursive — covered by SST2437
dotnet_diagnostic.S3869.severity = none # "SafeHandle.DangerousGetHandle" should not be called -> replaced by SST2484
dotnet_diagnostic.S3889.severity = none # "Thread.Resume" and "Thread.Suspend" should not be used -> replaced by obsolete or compiler
dotnet_diagnostic.S4159.severity = none # Classes should implement their "ExportAttribute" interfaces — covered by SST2472

# Critical bugs
dotnet_diagnostic.S2551.severity = none # Shared resources should not be used for locking — covered by SST1902
dotnet_diagnostic.S2952.severity = none # Classes should "Dispose" of members from the classes' own "Dispose" methods -> replaced by SST2315
dotnet_diagnostic.S3449.severity = none # Right operands of shift operators should be integers -> replaced by SST1478
dotnet_diagnostic.S4275.severity = none # Getters and setters should access the expected fields — covered by SST2422
dotnet_diagnostic.S4277.severity = none # "Shared" parts should not be created with "new" — covered by SST2473
dotnet_diagnostic.S4583.severity = none # Calls to delegate's method "BeginInvoke" should be paired with calls to "EndInvoke" -> replaced by obsolete (APM BeginInvoke/EndInvoke)
dotnet_diagnostic.S4586.severity = none # Non-async "Task/Task<T>" methods should not return null — covered by PSH1312
dotnet_diagnostic.S5856.severity = none # Regular expressions should be syntactically valid — covered by SST2444
dotnet_diagnostic.S6674.severity = none # Log message template should be syntactically correct — covered by SST2441

# Major bugs
dotnet_diagnostic.S1244.severity = none # Floating point numbers should not be tested for equality — covered by SST1473
dotnet_diagnostic.S1656.severity = none # Variables should not be self-assigned — covered by SST1189
dotnet_diagnostic.S1751.severity = none # Loops with at most one iteration should be refactored - covered by SST1444
dotnet_diagnostic.S1764.severity = none # Identical expressions should not be used on both sides of operators — covered by SST1474
dotnet_diagnostic.S1848.severity = none # Objects should not be created to be dropped immediately without being used -> replaced by SST1480
dotnet_diagnostic.S1862.severity = none # Related "if/else if" statements should not have the same condition — covered by SST1475
dotnet_diagnostic.S2114.severity = none # Collections should not be passed as arguments to their own methods — covered by SST2419
dotnet_diagnostic.S2123.severity = none # Values should not be uselessly incremented -> replaced by SST2222
dotnet_diagnostic.S2201.severity = none # Methods without side effects should not have their return values ignored — covered by SST2418
dotnet_diagnostic.S2225.severity = none # "ToString()" method should not return null — covered by SST2431
dotnet_diagnostic.S2251.severity = none # A "for" loop update clause should move the counter in the right direction — covered by SST2412
dotnet_diagnostic.S2252.severity = none # For-loop conditions should be true at least once — covered by SST2413
dotnet_diagnostic.S2445.severity = none # Blocks should be synchronized on read-only fields — covered by SST1904
dotnet_diagnostic.S2688.severity = none # "NaN" should not be used in comparisons — covered by SST1473
dotnet_diagnostic.S2757.severity = none # Non-existent operators like "=+" should not be used — covered by SST2417
dotnet_diagnostic.S2761.severity = none # Doubled prefix operators "!!" and "~~" should not be used — covered by SST1190
dotnet_diagnostic.S2995.severity = none # "Object.ReferenceEquals" should not be used for value types -> replaced by CA2013
dotnet_diagnostic.S2996.severity = none # "ThreadStatic" fields should not be initialized -> replaced by CA2019
dotnet_diagnostic.S2997.severity = none # "IDisposables" created in a "using" statement should not be returned — covered by SST2423
dotnet_diagnostic.S3005.severity = none # "ThreadStatic" should not be used on non-static fields -> replaced by CA2259
dotnet_diagnostic.S3168.severity = none # "async" methods should not return "void" — covered by SST1905
dotnet_diagnostic.S3172.severity = none # Delegates should not be subtracted — covered by SST2448
dotnet_diagnostic.S3244.severity = none # Anonymous delegates should not be used to unsubscribe from Events — covered by SST2449
dotnet_diagnostic.S3249.severity = none # Covered by SST1447 (canonical)
dotnet_diagnostic.S3263.severity = none # Static fields should appear in the order they must be initialized — covered by SST2428
dotnet_diagnostic.S3343.severity = none # Caller information parameters should come at the end of the parameter list — covered by SST2433
dotnet_diagnostic.S3346.severity = none # Expressions used in "Debug.Assert" should not produce side effects — covered by SST2450
dotnet_diagnostic.S3453.severity = none # Classes should not have only "private" constructors — covered by SST2451
dotnet_diagnostic.S3466.severity = none # Optional parameters should be passed to "base" calls — covered by SST2425
dotnet_diagnostic.S3598.severity = none # One-way "OperationContract" methods should have "void" return type -> replaced by obsolete (WCF)
dotnet_diagnostic.S3603.severity = none # Methods with "Pure" attribute should return a value — covered by SST2452
dotnet_diagnostic.S3610.severity = none # Nullable type comparison should not be redundant -> replaced by compiler CS0472
dotnet_diagnostic.S3903.severity = none # Types should be defined in named namespaces — covered by SST2312
dotnet_diagnostic.S3923.severity = none # All branches in a conditional structure should not have exactly the same implementation — covered by SST1476
dotnet_diagnostic.S3926.severity = none # Deserialization methods should be provided for "OptionalField" members -> replaced by obsolete (legacy binary serialization)
dotnet_diagnostic.S3927.severity = none # Serialization event handlers should be implemented correctly — covered by SST2430
dotnet_diagnostic.S3981.severity = none # Collection sizes and array length comparisons should make sense — covered by SST1479
dotnet_diagnostic.S3984.severity = none # Exceptions should not be created without being thrown — covered by SST1480
dotnet_diagnostic.S4143.severity = none # Collection elements should not be replaced unconditionally — covered by SST1487
dotnet_diagnostic.S4210.severity = none # Windows Forms entry points should be marked with STAThread -> replaced by SST2706
dotnet_diagnostic.S4260.severity = none # "ConstructorArgument" parameters should exist in constructors -> replaced by SST2487
dotnet_diagnostic.S4428.severity = none # "PartCreationPolicyAttribute" should be used with "ExportAttribute" — covered by SST2474
dotnet_diagnostic.S6507.severity = none # Blocks should not be synchronized on local variables — covered by SST1903
dotnet_diagnostic.S6677.severity = none # Message template placeholders should be unique — covered by SST2442
dotnet_diagnostic.S6797.severity = none # Blazor query parameter type should be supported -> replaced by SST2702
dotnet_diagnostic.S6798.severity = none # [JSInvokable] attribute should only be used on public methods -> replaced by SST2701
dotnet_diagnostic.S6800.severity = none # Component parameter type should match the route parameter type constraint -> replaced by SST2703
dotnet_diagnostic.S6930.severity = none # Backslash should be avoided in route templates -> replaced by SST2700

# Minor bugs
dotnet_diagnostic.S1206.severity = none # "Equals(Object)" and "GetHashCode()" should be overridden in pairs - DUPLICATE CA2218
dotnet_diagnostic.S1226.severity = none # Method parameters, caught exceptions and foreach variables' initial values should not be ignored
dotnet_diagnostic.S2183.severity = none # Integral numbers should not be shifted by zero or more than their number of bits-1 — covered by SST1478
dotnet_diagnostic.S2184.severity = none # Results of integer division should not be assigned to floating point variables — covered by SST1477
dotnet_diagnostic.S2328.severity = none # "GetHashCode" should not reference mutable fields — covered by SST1482
dotnet_diagnostic.S2345.severity = none # Flags enumerations should explicitly initialize all their members — covered by SST2303
dotnet_diagnostic.S2674.severity = none # The length returned from a stream read should be checked — covered by SST2446
dotnet_diagnostic.S2934.severity = none # Property assignments should not be made for "readonly" fields not constrained to reference types — covered by SST2421
dotnet_diagnostic.S2955.severity = none # Generic parameters not constrained to reference types should not be compared to "null" -> replaced by compiler CS0019/CS0037
dotnet_diagnostic.S3363.severity = none # Date and time should not be used as a type for primary keys — covered by SST2475
dotnet_diagnostic.S3397.severity = none # "base.Equals" should not be used to check for reference equality in "Equals" if "base" is not "object" — covered by SST2435
dotnet_diagnostic.S3456.severity = none # "string.ToCharArray()" and "ReadOnlySpan<T>.ToArray()" should not be called redundantly — covered by PSH1217
dotnet_diagnostic.S3887.severity = none # Mutable, non-private fields should not be "readonly" — covered by SST2322

# Blocker vulnerabilities
dotnet_diagnostic.S2115.severity = none # A secure password should be used when connecting to a database -> replaced by SES1203
dotnet_diagnostic.S2755.severity = none # XML parsers should not be vulnerable to XXE attacks -> replaced by CA3075
dotnet_diagnostic.S3884.severity = none # "CoSetProxyBlanket" and "CoInitializeSecurity" should not be used -> replaced by obsolete (COM interop security)
dotnet_diagnostic.S6418.severity = none # Secrets should not be hard-coded — covered by SES1201

# Critical vulnerabilities
dotnet_diagnostic.S4423.severity = none # Weak SSL/TLS protocols should not be used -> replaced by CA5397/CA5398
dotnet_diagnostic.S4426.severity = none # Cryptographic keys should be robust -> replaced by CA5385 (RSA) / CA5384 (DSA)
dotnet_diagnostic.S4433.severity = none # LDAP connections should be authenticated -> replaced by SES1310
dotnet_diagnostic.S4830.severity = none # Server certificates should be verified during SSL/TLS connections -> replaced by SES1102 or SES1108
dotnet_diagnostic.S5344.severity = none # Passwords should not be stored in plaintext or with a fast hashing algorithm -> replaced by SES1009
dotnet_diagnostic.S5445.severity = none # Insecure temporary file creation methods should not be used -> replaced by SES1307
dotnet_diagnostic.S5542.severity = none # Encryption algorithms should be used with secure mode and padding scheme -> replaced by CA5358
dotnet_diagnostic.S5547.severity = none # Cipher algorithms should be robust -> replaced by CA5351
dotnet_diagnostic.S5659.severity = none # JWT should be signed and verified with strong cipher algorithms -> replaced by SES1503

# Major vulnerabilities
dotnet_diagnostic.S2068.severity = none # Credentials should not be hard-coded -> replaced by SES1201
dotnet_diagnostic.S2612.severity = none # File permissions should not be set to world-accessible values -> replaced by SES1308
dotnet_diagnostic.S4211.severity = none # Members should not have conflicting transparency annotations -> replaced by obsolete (Code Access Security)
dotnet_diagnostic.S4212.severity = none # Serialization constructors should be secured -> replaced by obsolete (Code Access Security)
dotnet_diagnostic.S6377.severity = none # XML signatures should be validated securely -> replaced by SES1008
dotnet_diagnostic.S7039.severity = none # Content Security Policies should be restrictive -> replaced by SES1515

# Blocker code smells
dotnet_diagnostic.S1147.severity = none # Exit methods should not be called — covered by SST2321
dotnet_diagnostic.S1451.severity = none # Track lack of copyright and license headers
dotnet_diagnostic.S2178.severity = none # Short-circuit logic should be used in boolean contexts — covered by SST2415
dotnet_diagnostic.S2187.severity = none # Test classes should contain at least one test case — covered by SST2504
dotnet_diagnostic.S2306.severity = none # "async" and "await" should not be used as identifiers -> replaced by compiler (contextual keyword)
dotnet_diagnostic.S2368.severity = none # Public methods should not have multidimensional array parameters — jagged arrays are the chosen layout for hot-path lookup tables
dotnet_diagnostic.S2387.severity = none # Child class fields should not shadow parent class fields — covered by SST1484
dotnet_diagnostic.S2437.severity = none # Unnecessary bit operations should not be performed — covered by SST1481
dotnet_diagnostic.S2699.severity = none # Tests should include assertions -> replaced by SST2500
dotnet_diagnostic.S2953.severity = none # Methods named "Dispose" should implement "IDisposable.Dispose" — covered by SST2316
dotnet_diagnostic.S2970.severity = none # Assertions should be complete -> replaced by SST2508
dotnet_diagnostic.S3060.severity = none # "is" should not be used with "this" -> replaced by SST2327
dotnet_diagnostic.S3237.severity = none # "value" contextual keyword should be used — covered by SST2429
dotnet_diagnostic.S3427.severity = none # Method overloads with default parameter values should not overlap — covered by SST2319
dotnet_diagnostic.S3433.severity = none # Test method signatures should be correct -> replaced by SST2509
dotnet_diagnostic.S3443.severity = none # Type should not be examined on "System.Type" instances — covered by SST2432
dotnet_diagnostic.S3875.severity = none # "operator==" should not be overloaded on reference types -> replaced by SST2464
dotnet_diagnostic.S3877.severity = none # Exceptions should not be thrown from unexpected methods — covered by SST1485
dotnet_diagnostic.S4462.severity = none # Calls to "async" methods should not be blocking - covered by PSH1315
dotnet_diagnostic.S6422.severity = none # Calls to "async" methods should not be blocking in Azure Functions — covered by PSH1315
dotnet_diagnostic.S6424.severity = none # Interfaces for durable entities should satisfy the restrictions -> off: Durable Entity-specific; not used in this library

# Critical code smells
dotnet_diagnostic.S1006.severity = none # Method overrides should not change parameter defaults — covered by SST2424
dotnet_diagnostic.S1067.severity = none # Expressions should not be too complex
dotnet_diagnostic.S1163.severity = none # Exceptions should not be thrown in finally blocks -> replaced by CA2219
dotnet_diagnostic.S1186.severity = none # Methods should not be empty — covered by SST1438
dotnet_diagnostic.S121.severity = none # Control structures should use curly braces (kept over SA1503 — Sonar 20ms vs SA1503 50ms) -> replaced by SST1503
dotnet_diagnostic.S1215.severity = none # "GC.Collect" should not be called — covered by PSH1021
dotnet_diagnostic.S126.severity = none # "if ... else if" constructs should end with "else" clauses
dotnet_diagnostic.S131.severity = none # "switch/Select" statements should contain a "default/Case Else" clauses
dotnet_diagnostic.S134.severity = none # Control flow statements "if", "switch", "for", "foreach", "while", "do"  and "try" should not be nested too deeply
dotnet_diagnostic.S1541.severity = none # Methods and properties should not be too complex - covered by SST1442
dotnet_diagnostic.S1699.severity = none # Constructors should only call non-overridable methods — covered by SST1483
dotnet_diagnostic.S1821.severity = none # "switch" statements should not be nested -> replaced by SST2252
dotnet_diagnostic.S1944.severity = none # Invalid casts should be avoided -> replaced by compiler CS0030
dotnet_diagnostic.S1994.severity = none # "for" loop increment clauses should modify the loops' counters — covered by SST2411
dotnet_diagnostic.S2197.severity = none # Modulus results should not be checked for direct equality — covered by SST2416
dotnet_diagnostic.S2198.severity = none # Unnecessary mathematical comparisons should not be made -> replaced by SST2489
dotnet_diagnostic.S2223.severity = none # Non-constant static fields should not be visible - DUPLICATE CA2211
dotnet_diagnostic.S2290.severity = none # Field-like events should not be virtual -> replaced by SST2456
dotnet_diagnostic.S2291.severity = none # Overflow checking should not be disabled for "Enumerable.Sum" — covered by SST2457
dotnet_diagnostic.S2302.severity = none # "nameof" should be used — covered by SST1415
dotnet_diagnostic.S2330.severity = none # Array covariance should not be used — covered by SST2434
dotnet_diagnostic.S2339.severity = none # Public constant members should not be used — covered by SST2311
dotnet_diagnostic.S2346.severity = none # Flags enumerations zero-value members should be named "None" - DUPLICATE CA1008
dotnet_diagnostic.S2360.severity = none # Optional parameters should not be used — conflicts with SST2433, which owns caller-info parameters requiring a default
dotnet_diagnostic.S2365.severity = none # Properties should not make collection or array copies — covered by PSH1017
dotnet_diagnostic.S2479.severity = none # Whitespace and control characters in string literals should be explicit — covered by SST1192
dotnet_diagnostic.S2692.severity = none # "IndexOf" checks should not be for positive numbers — covered by SST2420
dotnet_diagnostic.S2696.severity = none # Instance members should not write to "static" fields -> replaced by SST2402
dotnet_diagnostic.S2701.severity = none # Literal boolean values should not be used in assertions — covered by SST2503
dotnet_diagnostic.S3215.severity = none # "interface" instances should not be cast to concrete types -> deliberately unenforced, same reason as SST2326
dotnet_diagnostic.S3216.severity = none # "ConfigureAwait(false)" should be used -> replaced by CA2007
dotnet_diagnostic.S3217.severity = none # "Explicit" conversions of "foreach" loops should not be used — covered by SST2225
dotnet_diagnostic.S3218.severity = none # Inner class members should not shadow outer class "static" or type members — covered by SST1484
dotnet_diagnostic.S3265.severity = none # Non-flags enums should not be used in bitwise operations — covered by SST2458
dotnet_diagnostic.S3353.severity = none # Unchanged variables should be marked as "const" — covered by PSH1402
dotnet_diagnostic.S3447.severity = none # "[Optional]" should not be used on "ref" or "out" parameters — covered by SST2459
dotnet_diagnostic.S3451.severity = none # "[DefaultValue]" should not be used when "[DefaultParameterValue]" is meant — covered by SST2460
dotnet_diagnostic.S3600.severity = none # "params" should not be introduced on overrides — covered by SST2426
dotnet_diagnostic.S3776.severity = none # Cognitive Complexity of methods should not be too high - covered by SST1443
dotnet_diagnostic.S3871.severity = none # Exception types should be "public" -> replaced by CA1064
dotnet_diagnostic.S3874.severity = none # "out" and "ref" parameters — repo idiom is TryX(..., out T value)
dotnet_diagnostic.S3904.severity = none # Assemblies should have version information -> replaced by obsolete (SDK supplies assembly version)
dotnet_diagnostic.S3937.severity = none # Number patterns should be regular — covered by SST1119
dotnet_diagnostic.S3972.severity = none # Conditionals should start on new lines — covered by SST1146
dotnet_diagnostic.S3973.severity = none # A conditionally executed single line should be denoted by indentation -> replaced by SST1503
dotnet_diagnostic.S3998.severity = none # Threads should not lock on objects with weak identity -> replaced by SST1902
dotnet_diagnostic.S4000.severity = none # Pointers to unmanaged memory should not be visible -> replaced by SST2328
dotnet_diagnostic.S4015.severity = none # Inherited member visibility should not be decreased — covered by SST2462
dotnet_diagnostic.S4019.severity = none # Base class methods should not be hidden — covered by SST2427
dotnet_diagnostic.S4025.severity = none # Child class fields should not differ from parent class fields only by capitalization — covered by SST2463
dotnet_diagnostic.S4039.severity = none # Interface methods should be callable by derived types - DUPLICATE CA1033
dotnet_diagnostic.S4487.severity = none # Unread "private" fields should be removed
dotnet_diagnostic.S4524.severity = none # "default" clauses should be first or last — covered by SST1219
dotnet_diagnostic.S4635.severity = none # Start index should be used instead of calling Substring — covered by PSH1218
dotnet_diagnostic.S5034.severity = none # "ValueTask" should be consumed correctly — covered by PSH1316
dotnet_diagnostic.S6967.severity = none # ModelState.IsValid should be called in controller actions -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S8367.severity = none # Identifiers should not conflict with the C# 14 "field" contextual keyword - the C# 14 compiler reports this: CS9273 (error) for a local named field in an accessor, CS9258 (warning) for a rebinding read
dotnet_diagnostic.S8368.severity = none # Identifiers should not conflict with the C# 14 "extension" contextual keyword - the C# 14 compiler reports this as CS9306, and SST1300 already flags the lowercase type name
dotnet_diagnostic.S8380.severity = none # Return types named "partial" should be escaped with "@" - the compiler reports this as CS8981, and SST1300 already flags the lowercase type name
dotnet_diagnostic.S8381.severity = none # "scoped" should be escaped when used as an identifier or type name in parenthesized lambda parameter lists -> replaced by compiler
dotnet_diagnostic.S927.severity = none # Parameter names should match base declaration and other partial definitions - DUPLICATE CA1725

# Major code smells
dotnet_diagnostic.S103.severity = none # Lines should not be too long — covered by SST1521
dotnet_diagnostic.S104.severity = none # Files should not have too many lines of code — covered by SST1522
dotnet_diagnostic.S106.severity = none # Covered by SST1449 (canonical)
dotnet_diagnostic.S1066.severity = none # Mergeable "if" statements should be combined — covered by SST2013
dotnet_diagnostic.S107.severity = none # Methods should not have too many parameters — covered by SST1472
dotnet_diagnostic.S108.severity = none # Nested blocks of code should not be left empty — covered by SST1439
dotnet_diagnostic.S109.severity = none # Magic numbers should not be used — covered by SST1471
dotnet_diagnostic.S110.severity = none # Inheritance tree of classes should not be too deep — covered by SST1446
dotnet_diagnostic.S1110.severity = none # Redundant pairs of parentheses should be removed — covered by SST1459
dotnet_diagnostic.S1117.severity = none # Local variables should not shadow class fields or properties — covered by SST1484
dotnet_diagnostic.S1118.severity = none # Utility classes should not have public constructors - DUPLICATE CA1052
dotnet_diagnostic.S112.severity = none # General or reserved exceptions should never be thrown — covered by SST2409
dotnet_diagnostic.S1121.severity = none # Assignments should not be made from within sub-expressions — covered by SST1187
dotnet_diagnostic.S1123.severity = none # "Obsolete" attributes should include explanations — covered by SST2308
dotnet_diagnostic.S1134.severity = none # Track uses of "FIXME" tags -> off: TODO comment tracker; not enforced here
dotnet_diagnostic.S1144.severity = none # Covered by SST1440 (canonical)
dotnet_diagnostic.S1151.severity = none # "switch case" clauses should not have too many lines of code — covered by SST1524
dotnet_diagnostic.S1168.severity = none # Empty arrays and collections should be returned instead of null — covered by SST2306
dotnet_diagnostic.S1172.severity = none # Unused method parameters should be removed — covered by SST1461
dotnet_diagnostic.S1200.severity = none # Classes should not be coupled to too many other classes
dotnet_diagnostic.S122.severity = none # Statements should be on separate lines — covered by SST1107
dotnet_diagnostic.S125.severity = none # Sections of code should not be commented out — covered by SST1148
dotnet_diagnostic.S127.severity = none # "for" loop stop conditions should be invariant — covered by SST2465
dotnet_diagnostic.S138.severity = none # Functions should not have too many lines of code — covered by SST1523
dotnet_diagnostic.S1479.severity = none # "switch" statements with many "case" clauses — covered by SST1423
dotnet_diagnostic.S1607.severity = none # Tests should not be ignored -> off: ignored-test tracker; not enforced here
dotnet_diagnostic.S1696.severity = none # NullReferenceException should not be caught — covered by SST2401
dotnet_diagnostic.S1854.severity = none # Unused assignments should be removed - DUPLICATE IDE0059
dotnet_diagnostic.S1871.severity = none # Two branches in a conditional structure should not have exactly the same implementation — covered by SST2414
dotnet_diagnostic.S2139.severity = none # Exceptions should be either logged or rethrown but not both -> replaced by SST2488
dotnet_diagnostic.S2166.severity = none # Classes named like "Exception" should extend "Exception" or a subclass - DUPLICATE CA1710
dotnet_diagnostic.S2234.severity = none # Arguments should be passed in the same order as the method parameters -> replaced by SST2400
dotnet_diagnostic.S2326.severity = none # Covered by SST1452 (canonical)
dotnet_diagnostic.S2327.severity = none # "try" statements with identical "catch" and/or "finally" blocks should be merged -> replaced by SST2490
dotnet_diagnostic.S2357.severity = none # Fields should be private — duplicate of SST1401 (canonical); fields intentionally exposed (e.g. public test fields for reflection) already carry per-site SST1401 suppressions
dotnet_diagnostic.S2372.severity = none # Exceptions should not be thrown from property getters — covered by SST1485
dotnet_diagnostic.S2376.severity = none # Write-only properties should not be used — covered by SST1421
dotnet_diagnostic.S2629.severity = none # Logging templates should be constant -> replaced by CA2254
dotnet_diagnostic.S2681.severity = none # Multiline blocks should be enclosed in curly braces — covered by SST1503
dotnet_diagnostic.S2743.severity = none # Static fields should not be used in generic types - DUPLICATE CA1000 — covered by SST1431
dotnet_diagnostic.S2925.severity = none # "Thread.Sleep" should not be used in tests — covered by SST2506
dotnet_diagnostic.S2933.severity = none # Fields that are only assigned in the constructor should be "readonly" - DUPLICATE IDE0044
dotnet_diagnostic.S2971.severity = none # LINQ expressions should be simplified — covered by PSH1101/PSH1102
dotnet_diagnostic.S3010.severity = none # Static fields should not be updated in constructors — covered by SST2402
dotnet_diagnostic.S3011.severity = none # Reflection should not be used to increase accessibility of classes, methods, or fields -> replaced by SES1406
dotnet_diagnostic.S3059.severity = none # Types should not have members with visibility set higher than the type's visibility
dotnet_diagnostic.S3063.severity = none # "StringBuilder" data should be used — covered by SST2408
dotnet_diagnostic.S3169.severity = none # Multiple "OrderBy" calls should not be used — covered by PSH1108
dotnet_diagnostic.S3246.severity = none # Generic type parameters should be co/contravariant when possible -> off: low-precision variance suggestion; not enforced
dotnet_diagnostic.S3262.severity = none # "params" should be used on overrides — covered by SST2426
dotnet_diagnostic.S3264.severity = none # Events should be invoked — covered by SST2407
dotnet_diagnostic.S3358.severity = none # Ternary operators should not be nested — covered by SST1147
dotnet_diagnostic.S3366.severity = none # "this" should not be exposed from constructors — covered by SST2403
dotnet_diagnostic.S3415.severity = none # Assertion arguments should be passed in the correct order — covered by SST2502
dotnet_diagnostic.S3431.severity = none # "[ExpectedException]" should not be used — covered by SST2507
dotnet_diagnostic.S3442.severity = none # "abstract" classes should not have "public" constructors — covered by SST1428
dotnet_diagnostic.S3445.severity = none # Exceptions should not be explicitly rethrown — covered by SST1430
dotnet_diagnostic.S3457.severity = none # Composite format strings should be used correctly — covered by SST1454
dotnet_diagnostic.S3597.severity = none # "ServiceContract" and "OperationContract" attributes should be used together -> replaced by obsolete (WCF)
dotnet_diagnostic.S3880.severity = none # Finalizers should not be empty — covered by PSH1002
dotnet_diagnostic.S3881.severity = none # "IDisposable" should be implemented correctly — covered by SST2300
dotnet_diagnostic.S3885.severity = none # "Assembly.Load" should be used -> replaced by SST2486
dotnet_diagnostic.S3898.severity = none # Covered by PSH1005 (canonical)
dotnet_diagnostic.S3902.severity = none # Covered by PSH1404 (canonical)
dotnet_diagnostic.S3906.severity = none # Event Handlers should have the correct signature — covered by SST2304
dotnet_diagnostic.S3908.severity = none # Generic event handlers should be used -> replaced by SST2304
dotnet_diagnostic.S3909.severity = none # Collections should implement the generic interface -> replaced by CA1010
dotnet_diagnostic.S3925.severity = none # "ISerializable" should be implemented correctly - BinaryFormatter / ISerializable serialization is obsoleted (SYSLIB0050/0051) in modern .NET; we do not opt into legacy serialization for any exception type
dotnet_diagnostic.S3928.severity = none # Parameter names used into ArgumentException constructors should match an existing one - DUPLICATE CA2208
dotnet_diagnostic.S3956.severity = none # "Generic.List" instances should not be part of public APIs
dotnet_diagnostic.S3971.severity = none # "GC.SuppressFinalize" should not be called — conflicts with PSH1008, which owns the pointless-SuppressFinalize direction and exempts unsealed types
dotnet_diagnostic.S3990.severity = none # Assemblies should be marked as CLS compliant -> replaced by CA1014
dotnet_diagnostic.S3992.severity = none # Assemblies should explicitly specify COM visibility -> replaced by CA1017
dotnet_diagnostic.S3993.severity = none # Custom attributes should be marked with "System.AttributeUsageAttribute" -> replaced by CA1018
dotnet_diagnostic.S3994.severity = none # URI Parameters should not be strings
dotnet_diagnostic.S3995.severity = none # URI return values should not be strings
dotnet_diagnostic.S3996.severity = none # URI properties should not be strings
dotnet_diagnostic.S3997.severity = none # String URI overloads should call "System.Uri" overloads -> replaced by CA1054/CA1056/CA1057
dotnet_diagnostic.S4002.severity = none # Disposable types should declare finalizers — covered by SST2317
dotnet_diagnostic.S4004.severity = none # Collection properties should be readonly — covered by SST2305
dotnet_diagnostic.S4005.severity = none # "System.Uri" arguments should be used instead of strings
dotnet_diagnostic.S4016.severity = none # Enumeration members should not be named "Reserved" -> replaced by CA1700
dotnet_diagnostic.S4017.severity = none # Method signatures should not contain nested generic types
dotnet_diagnostic.S4035.severity = none # Classes implementing "IEquatable<T>" should be sealed — covered by SST2301
dotnet_diagnostic.S4050.severity = none # Operators should be overloaded consistently — covered by SST2302
dotnet_diagnostic.S4055.severity = none # Literals should not be passed as localized parameters
dotnet_diagnostic.S4057.severity = none # Locales should be set for data types -> replaced by obsolete
dotnet_diagnostic.S4059.severity = none # Property names should not match get methods - DUPLICATE CA1721
dotnet_diagnostic.S4070.severity = none # Non-flags enums should not be marked with "FlagsAttribute" — covered by SST2303
dotnet_diagnostic.S4144.severity = none # Methods should not have identical implementations — covered by SST2318
dotnet_diagnostic.S4200.severity = none # Native methods should be wrapped -> replaced by CA1401
dotnet_diagnostic.S4214.severity = none # "P/Invoke" methods should not be visible - DUPLICATE CA1401
dotnet_diagnostic.S4220.severity = none # Events should have proper arguments — covered by SST2436
dotnet_diagnostic.S4456.severity = none # Parameter validation in yielding methods should be wrapped — covered by SST2404
dotnet_diagnostic.S4457.severity = none # Parameter validation in "async"/"await" methods should be wrapped — covered by SST2325
dotnet_diagnostic.S4545.severity = none # "DebuggerDisplayAttribute" strings should reference existing members — covered by SST2405
dotnet_diagnostic.S4581.severity = none # "new Guid()" should not be used — covered by SST2012
dotnet_diagnostic.S6354.severity = none # Use a testable date/time provider — covered by SST2010
dotnet_diagnostic.S6419.severity = none # Azure Functions should be stateless -> off: Azure Functions-specific; not used in this library
dotnet_diagnostic.S6420.severity = none # Client instances should not be recreated on each Azure Function invocation — covered by PSH1418
dotnet_diagnostic.S6421.severity = none # Azure Functions should use Structured Error Handling -> off: Azure Functions-specific; not used in this library
dotnet_diagnostic.S6423.severity = none # Azure Functions should log all failures -> off: Azure Functions-specific; not used in this library
dotnet_diagnostic.S6561.severity = none # Avoid using "DateTime.Now" for benchmarking or timing operations — covered by PSH1408
dotnet_diagnostic.S6562.severity = none # Covered by SST1451 (canonical)
dotnet_diagnostic.S6563.severity = none # Use UTC when recording DateTime instants — covered by SST2011
dotnet_diagnostic.S6566.severity = none # Use "DateTimeOffset" instead of "DateTime" — covered by SST2016
dotnet_diagnostic.S6575.severity = none # Use "TimeZoneInfo.FindSystemTimeZoneById" without converting the timezones with "TimezoneConverter" -> replaced by PSH1419
dotnet_diagnostic.S6580.severity = none # Use a format provider when parsing date and time - DUPLICATE CA1305
dotnet_diagnostic.S6673.severity = none # Log message template placeholders should be in the right order — covered by SST2440
dotnet_diagnostic.S6802.severity = none # Using lambda expressions in loops should be avoided in Blazor markup section -> replaced by PSH1600
dotnet_diagnostic.S6803.severity = none # Parameters with SupplyParameterFromQuery attribute should be used only in routable components -> off: Blazor-specific; no Blazor surface in this library
dotnet_diagnostic.S6931.severity = none # ASP.NET controller actions should not have a route template starting with "/" -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S6932.severity = none # Use model binding instead of reading raw request data -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S6934.severity = none # A Route attribute should be added to the controller when a route template is specified at the action level -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S6960.severity = none # Controllers should not have mixed responsibilities -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S6961.severity = none # API Controllers should derive from ControllerBase instead of Controller -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S6962.severity = none # You should pool HTTP connections with HttpClientFactory — covered by PSH1418
dotnet_diagnostic.S6964.severity = none # Value type property used as input in a controller action should be nullable, required or annotated with the JsonRequiredAttribute to avoid under-posting. -> replaced by SST2705 (opt-in)
dotnet_diagnostic.S6965.severity = none # REST API actions should be annotated with an HTTP verb attribute -> replaced by SST2704
dotnet_diagnostic.S6966.severity = none # Awaitable method should be used — covered by PSH1313
dotnet_diagnostic.S6968.severity = none # Actions that return a value should be annotated with ProducesResponseTypeAttribute containing the return type -> off: ASP.NET MVC-specific; no controllers in this library
dotnet_diagnostic.S881.severity = none # Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression — covered by SST2015
dotnet_diagnostic.S907.severity = none # "goto" statement should not be used — covered by SST2014

# Minor code smells
dotnet_diagnostic.S100.severity = none # Methods and properties should be named in PascalCase — covered by SST1300
dotnet_diagnostic.S101.severity = none # Types should be named in PascalCase — covered by SST1300
dotnet_diagnostic.S105.severity = none # Tabulation characters should not be used — covered by SST1027
dotnet_diagnostic.S1104.severity = none # Fields should not have public accessibility - DUPLICATE CA1051
dotnet_diagnostic.S1109.severity = none # A close curly brace should be located at the beginning of a line — covered by SST1500
dotnet_diagnostic.S1116.severity = none # Empty statements should be removed - DUPLICATE SA1106
dotnet_diagnostic.S1125.severity = none # Boolean literals should not be redundant — covered by SST1182
dotnet_diagnostic.S1128.severity = none # Covered by SST1445 (canonical)
dotnet_diagnostic.S113.severity = none # Files should end with a newline
dotnet_diagnostic.S1155.severity = none # "Any()" should be used to test for emptiness — covered by PSH1119
dotnet_diagnostic.S1185.severity = none # Overriding members should do more than simply call the same member in the base class - DUPLICATE RCS1132
dotnet_diagnostic.S1192.severity = none # String literals should not be duplicated — covered by SST1486
dotnet_diagnostic.S1199.severity = none # Nested code blocks should not be used — covered by SST1138
dotnet_diagnostic.S1210.severity = none # "Equals" and the comparison operators should be overridden when implementing "IComparable" - DUPLICATE CA1036
dotnet_diagnostic.S1227.severity = none # break statements should not be used except for switch cases
dotnet_diagnostic.S1264.severity = none # A "while" loop should be used instead of a "for" loop — covered by SST2245
dotnet_diagnostic.S1301.severity = none # "switch" statements should have at least 3 "case" clauses
dotnet_diagnostic.S1312.severity = none # Logger fields should be "private static readonly"
dotnet_diagnostic.S1449.severity = none # Culture should be specified for "string" operations — covered by PSH1207
dotnet_diagnostic.S1450.severity = none # Private fields only used as local variables in methods should become local variables — covered by SST1422
dotnet_diagnostic.S1481.severity = none # Unused local variables should be removed — covered by SST1497
dotnet_diagnostic.S1643.severity = none # Covered by PSH1206 (canonical)
dotnet_diagnostic.S1659.severity = none # Multiple variables should not be declared on the same line — covered by SST1132
dotnet_diagnostic.S1694.severity = none # An abstract class should have both abstract and concrete methods — covered by SST2323
dotnet_diagnostic.S1698.severity = none # "==" should not be used when "Equals" is overridden — covered by SST1495
dotnet_diagnostic.S1858.severity = none # "ToString()" calls should not be redundant — covered by PSH1211
dotnet_diagnostic.S1905.severity = none # Redundant casts should not be used - DUPLICATE IDE0004 — covered by SST1175
dotnet_diagnostic.S1939.severity = none # Inheritance list should not be redundant — covered by SST1490 and SST1177
dotnet_diagnostic.S1940.severity = none # Boolean checks should not be inverted — covered by SST1172
dotnet_diagnostic.S2094.severity = none # Classes should not be empty — covered by SST1436
dotnet_diagnostic.S2148.severity = none # Underscores should be used to make large numbers readable — covered by SST1191
dotnet_diagnostic.S2156.severity = none # "sealed" classes should not have "protected" members — covered by SST1427
dotnet_diagnostic.S2219.severity = none # Runtime type checking should be simplified — covered by SST2007
dotnet_diagnostic.S2221.severity = none # "Exception" should not be caught
dotnet_diagnostic.S2292.severity = none # Trivial properties should be auto-implemented — covered by SST1420
dotnet_diagnostic.S2325.severity = none # Methods and properties that don't access instance data should be static - DUPLICATE CA1822
dotnet_diagnostic.S2333.severity = none # Redundant modifiers should not be used — covered by SST1419/SST1491
dotnet_diagnostic.S2342.severity = none # Enumeration types should comply with a naming convention — covered by SST1319
dotnet_diagnostic.S2344.severity = none # Enumeration type names should not have "Flags" or "Enum" suffixes - DUPLICATE CA1711
dotnet_diagnostic.S2386.severity = none # Mutable fields should not be "public static" — covered by SST1499
dotnet_diagnostic.S2486.severity = none # Generic exceptions should not be ignored — covered by SST1429
dotnet_diagnostic.S2737.severity = none # "catch" clauses should do more than rethrow — covered by SST1470
dotnet_diagnostic.S2760.severity = none # Sequential tests should not check the same condition — covered by SST1475
dotnet_diagnostic.S3052.severity = none # Covered by PSH1403 (canonical)
dotnet_diagnostic.S3220.severity = none # Method calls should not resolve ambiguously to overloads with "params" — covered by SST2467
dotnet_diagnostic.S3234.severity = none # Covered by PSH1008 (canonical)
dotnet_diagnostic.S3235.severity = none # Redundant parentheses should not be used — covered by SST1459
dotnet_diagnostic.S3236.severity = none # Covered by SST1448 (canonical)
dotnet_diagnostic.S3240.severity = none # The simplest possible condition syntax should be used - duplicate of SST1198
dotnet_diagnostic.S3241.severity = none # Methods should not return values that are never used -> off: needs whole-program analysis; not enforced here
dotnet_diagnostic.S3242.severity = none # Method parameters should be declared with base types
dotnet_diagnostic.S3247.severity = none # Duplicate casts should not be made — covered by SST1175
dotnet_diagnostic.S3251.severity = none # Implementations should be provided for "partial" methods — covered by SST2468
dotnet_diagnostic.S3253.severity = none # Constructor and destructor declarations should not be redundant — covered by SST1433
dotnet_diagnostic.S3254.severity = none # Default parameter values should not be passed as arguments — covered by SST1494
dotnet_diagnostic.S3256.severity = none # "string.IsNullOrEmpty" should be used — covered by PSH1204 (style configurable)
dotnet_diagnostic.S3257.severity = none # Declarations and initializations should be as concise as possible -> replaced by SST2202
dotnet_diagnostic.S3260.severity = none # Non-derived "private" classes and records should be "sealed" — covered by PSH1411
dotnet_diagnostic.S3261.severity = none # Namespaces should not be empty — covered by SST1435
dotnet_diagnostic.S3267.severity = none # Loops should be simplified with "LINQ" expressions
dotnet_diagnostic.S3376.severity = none # Attribute, EventArgs, and Exception type names should end with the type being extended - DUPLICATE CA1710
dotnet_diagnostic.S3398.severity = none # "private" methods called only by inner classes should be moved to those classes — covered by SST1498
dotnet_diagnostic.S3400.severity = none # Methods should not return constants — covered by SST1493
dotnet_diagnostic.S3416.severity = none # Loggers should be named for their enclosing types — covered by SST2443
dotnet_diagnostic.S3440.severity = none # Variables should not be checked against the values they're about to be assigned — covered by SST1492
dotnet_diagnostic.S3441.severity = none # Redundant property names should be omitted in anonymous classes — covered by SST1173
dotnet_diagnostic.S3444.severity = none # Interfaces should not simply inherit from base interfaces with colliding members — covered by SST2320
dotnet_diagnostic.S3450.severity = none # Parameters with "[DefaultParameterValue]" attributes should also be marked "[Optional]" -> replaced by obsolete (legacy DefaultParameterValue)
dotnet_diagnostic.S3458.severity = none # Empty "case" clauses that fall through to the "default" should be omitted — covered by SST1466
dotnet_diagnostic.S3459.severity = none # Unassigned members should be removed - the compiler reports this as CS0649; the rule only ever fires on private never-assigned fields
dotnet_diagnostic.S3532.severity = none # Empty "default" clauses should be removed — covered by SST1179
dotnet_diagnostic.S3604.severity = none # Member initializer values should not be redundant — covered by PSH1403
dotnet_diagnostic.S3626.severity = none # Jump statements should not be redundant — covered by SST1174
dotnet_diagnostic.S3717.severity = none # Track use of "NotImplementedException" -> replaced by SST2485
dotnet_diagnostic.S3872.severity = none # Parameter names should not duplicate the names of their methods -> replaced by SST1320
dotnet_diagnostic.S3876.severity = none # Strings or integral types should be used for indexers -> replaced by CA1043
dotnet_diagnostic.S3878.severity = none # Arrays should not be created for params parameters — covered by PSH1018
dotnet_diagnostic.S3897.severity = none # Classes that provide "Equals(<T>)" should implement "IEquatable<T>" -> replaced by CA1067
dotnet_diagnostic.S3962.severity = none # Covered by PSH1402 (canonical)
dotnet_diagnostic.S3963.severity = none # "static" fields should be initialized inline - DUPLICATE CA1810
dotnet_diagnostic.S3967.severity = none # Multidimensional arrays should not be used - DUPLICATE CA1814
dotnet_diagnostic.S4018.severity = none # All type parameters should be used in the parameter list to enable type inference — covered by SST2307
dotnet_diagnostic.S4022.severity = none # Enumerations should have "Int32" storage — covered by SST2313
dotnet_diagnostic.S4023.severity = none # Interfaces should not be empty — covered by SST1437
dotnet_diagnostic.S4026.severity = none # Assemblies should be marked with "NeutralResourcesLanguageAttribute" -> replaced by CA1824
dotnet_diagnostic.S4027.severity = none # Exceptions should provide standard constructors — covered by SST1488
dotnet_diagnostic.S4040.severity = none # Strings should be normalized to uppercase - DUPLICATE CA1308
dotnet_diagnostic.S4041.severity = none # Type names should not match namespaces - DUPLICATE CA1724
dotnet_diagnostic.S4047.severity = none # Generics should be used when appropriate -> off: fuzzy prefer-generics suggestion; not enforced
dotnet_diagnostic.S4049.severity = none # Properties should be preferred - DUPLICATE CA1024
dotnet_diagnostic.S4052.severity = none # Types should not extend outdated base types -> replaced by obsolete
dotnet_diagnostic.S4056.severity = none # Overloads with a "CultureInfo" or an "IFormatProvider" parameter should be used - DUPLICATE CA1305
dotnet_diagnostic.S4058.severity = none # Covered by PSH1207 (canonical)
dotnet_diagnostic.S4060.severity = none # Non-abstract attributes should be sealed - DUPLICATE CA1813
dotnet_diagnostic.S4061.severity = none # "params" should be used instead of "varargs" -> replaced by obsolete (__arglist varargs)
dotnet_diagnostic.S4069.severity = none # Operator overloads should have named alternatives - DUPLICATE CA2225
dotnet_diagnostic.S4136.severity = none # Method overloads should be grouped together — covered by SST1218
dotnet_diagnostic.S4201.severity = none # Null checks should not be combined with "is" operator checks — covered by SST2018
dotnet_diagnostic.S4225.severity = none # Extension methods should not extend "object" — covered by SST1706
dotnet_diagnostic.S4226.severity = none # Extensions should be in separate namespaces
dotnet_diagnostic.S4261.severity = none # Methods should be named according to their synchronicities - Async suffix not used
dotnet_diagnostic.S4663.severity = none # Covered by SST1120 (canonical)
dotnet_diagnostic.S6513.severity = none # "ExcludeFromCodeCoverage" attributes should include a justification - not available on net462 and older TFMs
dotnet_diagnostic.S6585.severity = none # Don't hardcode the format when turning dates and times to strings — covered by SST2445
dotnet_diagnostic.S6588.severity = none # Use the "UnixEpoch" field instead of creating "DateTime" instances that point to the beginning of the Unix epoch — covered by PSH1413
dotnet_diagnostic.S6594.severity = none # Covered by PSH1406 (canonical)
dotnet_diagnostic.S6602.severity = none # Covered by PSH1110 (canonical)
dotnet_diagnostic.S6603.severity = none # Covered by PSH1110 (canonical)
dotnet_diagnostic.S6605.severity = none # Covered by PSH1110 (canonical)
dotnet_diagnostic.S6607.severity = none # The collection should be filtered before sorting — covered by PSH1107
dotnet_diagnostic.S6608.severity = none # Covered by PSH1106 (canonical)
dotnet_diagnostic.S6609.severity = none # "Min/Max" properties of "Set" types should be used instead of the "Enumerable" extension methods — covered by PSH1122
dotnet_diagnostic.S6610.severity = none # Covered by PSH1201 (canonical)
dotnet_diagnostic.S6612.severity = none # The lambda parameter should be used instead of capturing arguments in "ConcurrentDictionary" methods — covered by PSH1006
dotnet_diagnostic.S6613.severity = none # "First" and "Last" properties of "LinkedList" should be used instead of the "First()" and "Last()" extension methods — covered by PSH1124
dotnet_diagnostic.S6617.severity = none # Covered by PSH1111 (canonical)
dotnet_diagnostic.S6618.severity = none # "string.Create" should be used instead of "FormattableString" — covered by PSH1209
dotnet_diagnostic.S6664.severity = none # The code block contains too many logging calls -> off: fuzzy too-many-logging-calls metric; not enforced
dotnet_diagnostic.S6667.severity = none # Logging in a catch clause should pass the caught exception as a parameter. — covered by SST2438
dotnet_diagnostic.S6668.severity = none # Logging arguments should be passed to the correct parameter — covered by SST2439
dotnet_diagnostic.S6669.severity = none # Logger field or property name should comply with a naming convention -> replaced by SST2601
dotnet_diagnostic.S6670.severity = none # "Trace.Write" and "Trace.WriteLine" should not be used — covered by SST2600
dotnet_diagnostic.S6672.severity = none # Generic logger injection should match enclosing type — covered by SST2443
dotnet_diagnostic.S6675.severity = none # "Trace.WriteLineIf" should not be used with "TraceSwitch" levels -> off: niche TraceSwitch misuse; not enforced here
dotnet_diagnostic.S6678.severity = none # Use PascalCase for named placeholders -> replaced by CA1727
dotnet_diagnostic.S818.severity = none # Literal suffixes should be upper case — covered by SST2244

# Informational code smells
dotnet_diagnostic.S1133.severity = none # Deprecated code should be removed — covered by SST2310
dotnet_diagnostic.S1135.severity = none # Track uses of "TODO" tags -> off: FIXME comment tracker; not enforced here
dotnet_diagnostic.S1309.severity = none # Track uses of in-source issue suppressions

# Uncategorized
dotnet_diagnostic.S9999-cpd.severity = error # Copy-paste token calculator
dotnet_diagnostic.S9999-log.severity = error # Log generator
dotnet_diagnostic.S9999-metadata.severity = error # File metadata generator
dotnet_diagnostic.S9999-metrics.severity = error # Metrics calculator
dotnet_diagnostic.S9999-symbolRef.severity = error # Symbol reference calculator
dotnet_diagnostic.S9999-telemetry.severity = error # Telemetry generator
dotnet_diagnostic.S9999-testMethodDeclaration.severity = error # Test method declarations generator
dotnet_diagnostic.S9999-token-type.severity = error # Token type calculator
dotnet_diagnostic.S9999-warning.severity = error # Analysis Warning generator

# Critical security hotspots
dotnet_diagnostic.S2245.severity = none # Using pseudorandom number generators (PRNGs) is security-sensitive - DUPLICATE CA5394
dotnet_diagnostic.S2257.severity = none # Using non-standard cryptographic algorithms is security-sensitive -> replaced by SES1007
dotnet_diagnostic.S4502.severity = none # Disabling CSRF protections is security-sensitive -> replaced by in-box ASP.NET antiforgery analyzer
dotnet_diagnostic.S4790.severity = none # Using weak hashing algorithms is security-sensitive -> replaced by CA5350/CA5351
dotnet_diagnostic.S4792.severity = none # Configuring loggers is security-sensitive -> off: logging-configuration audit hotspot; not enforced here
dotnet_diagnostic.S5042.severity = none # Expanding archive files without controlling resource consumption is security-sensitive -> off: unbounded decompression; needs taint analysis, out of scope
dotnet_diagnostic.S5332.severity = none # Using clear-text protocols is security-sensitive -> replaced by SES1106
dotnet_diagnostic.S5443.severity = none # Using publicly writable directories is security-sensitive -> replaced by SES1308

# Major security hotspots
dotnet_diagnostic.S1313.severity = none # Using hardcoded IP addresses is security-sensitive -> off: hardcoded-IP heuristic; too noisy to enforce
dotnet_diagnostic.S2077.severity = none # Formatting SQL queries is security-sensitive -> replaced by CA2100
dotnet_diagnostic.S5693.severity = none # Allowing requests with excessive content length is security-sensitive -> replaced by SES1505
dotnet_diagnostic.S5753.severity = none # Disabling ASP.NET "Request Validation" feature is security-sensitive -> replaced by obsolete (legacy ASP.NET request validation)
dotnet_diagnostic.S5766.severity = none # Creating Serializable objects without data validation checks is security-sensitive -> off: legacy BinaryFormatter deserialization; obsolete path, not used here
dotnet_diagnostic.S6444.severity = none # Not specifying a timeout for regular expressions is security-sensitive -> replaced by SES1509
dotnet_diagnostic.S6640.severity = none # Using unsafe code blocks is security-sensitive -> off: unsafe-code audit; not enforced here

# Minor security hotspots
dotnet_diagnostic.S2092.severity = none # Creating cookies without the "secure" flag is security-sensitive -> replaced by CA5382
dotnet_diagnostic.S3330.severity = none # Creating cookies without the "HttpOnly" flag is security-sensitive -> replaced by CA5383
dotnet_diagnostic.S4507.severity = none # Delivering code in production with debug features activated is security-sensitive -> off: debug features in production; partly covered by SES1506, rest not enforced
dotnet_diagnostic.S5122.severity = none # Having a permissive Cross-Origin Resource Sharing policy is security-sensitive -> replaced by SES1501

#############################################
# JetBrains ReSharper / Rider Inspections
#############################################
# Mirrors the CA / SA / RCS choices above for Rider and ReSharper users. Only
# inspections with a clear mapping to our Roslyn analyzer rules are listed;
# every other ReSharper inspection keeps its default severity. The goal is to
# avoid Rider double-reporting things the Roslyn analyzers already catch and
# to keep IDE severities in sync with CI-enforced severities.

###################
# ReSharper - Layout / Formatting (covered by StyleCop SA)
###################
resharper_redundant_linebreak_highlighting = none # covered by SA layout rules
resharper_missing_linebreak_highlighting = none # covered by SA layout rules
resharper_bad_empty_braces_line_breaks_highlighting = none # covered by SA1500
resharper_missing_indent_highlighting = none # covered by editorconfig indent_size
resharper_missing_blank_lines_highlighting = none # covered by SA1516 / SA1517
resharper_wrong_indent_size_highlighting = none # covered by editorconfig indent_size
resharper_bad_indent_highlighting = none # covered by editorconfig indent_size
resharper_bad_expression_braces_line_breaks_highlighting = none # covered by SA layout rules
resharper_multiple_spaces_highlighting = none # covered by SA1025
resharper_bad_expression_braces_indent_highlighting = none # covered by SA layout rules
resharper_bad_control_braces_indent_highlighting = none # covered by SA layout rules
resharper_bad_preprocessor_indent_highlighting = none # covered by SA layout rules
resharper_redundant_blank_lines_highlighting = none # covered by SA1516 / SA1507
resharper_multiple_statements_on_one_line_highlighting = none # covered by SA1119 / SA1503
resharper_bad_braces_spaces_highlighting = none # covered by SA1012 / SA1013
resharper_outdent_is_off_prev_level_highlighting = none # editorconfig indentation
resharper_bad_symbol_spaces_highlighting = none # covered by SA spacing rules
resharper_bad_colon_spaces_highlighting = none # covered by SA1024
resharper_bad_semicolon_spaces_highlighting = none # covered by SA1002
resharper_bad_square_brackets_spaces_highlighting = none # covered by SA1010 / SA1011
resharper_bad_parens_spaces_highlighting = none # covered by SA1008 / SA1009

###################
# ReSharper - 'this' qualifier (matches SA1101 = none)
###################
resharper_redundant_this_qualifier_highlighting = none # we don't follow the this. prefix style
resharper_arrange_this_qualifier_highlighting = none # we don't follow the this. prefix style
resharper_arrange_default_access_modifier_highlighting = none # SA1400 requires explicit access modifiers — don't suggest removing them
resharper_redundant_default_access_modifier_highlighting = none # SA1400 requires explicit access modifiers — don't suggest removing them
resharper_redundant_access_modifier_highlighting = none # access modifiers are deliberate and SA1400 requires them
resharper_arrange_type_member_modifiers_highlighting = none # SA1206 handles modifier ordering; don't duplicate
resharper_redundant_empty_switch_section_highlighting = none # handled by RCS1070

###################
# ReSharper - Redundancies / cleanup
###################
resharper_redundant_using_directive_highlighting = error # IDE0005 may not fire at compile time reliably — keep Rider nagging
resharper_redundant_qualifier_highlighting = error # IDE0001 may not fire at compile time reliably — keep Rider nagging
resharper_redundant_name_qualifier_highlighting = error # IDE0001 may not fire at compile time reliably — keep Rider nagging
resharper_redundant_base_qualifier_highlighting = none # IDE0009 is disabled (SA1101 = none) — don't nag in Rider either
resharper_redundant_cast_highlighting = none # handled by RCS1151
resharper_redundant_explicit_array_creation_highlighting = none # handled by RCS1014
resharper_redundant_empty_object_creation_argument_list_highlighting = none # handled by RCS1039
resharper_redundant_lambda_signature_parentheses_highlighting = error # IDE0063 may not fire at compile time reliably — keep Rider nagging
resharper_redundant_default_member_initializer_highlighting = none # handled by RCS1188
resharper_redundant_field_initializer_highlighting = none # handled by RCS1129
resharper_redundant_overriding_member_highlighting = none # handled by RCS1132
resharper_redundant_verbatim_string_prefix_highlighting = none # handled by RCS1192
resharper_redundant_string_interpolation_highlighting = none # handled by RCS1105 / RCS1214
resharper_redundant_to_string_call_highlighting = none # handled by RCS1097

###################
# ReSharper - Naming (matches SA/CA naming rules)
###################
resharper_inconsistent_naming_highlighting = none # too many false positives on test/fixture naming; SA1300 family covers the real cases

###################
# ReSharper - Unused code (matches CA1801 / CA1823 / IDE0051-0052)
###################
resharper_unused_parameter_local_highlighting = none # handled by CA1801 (private/internal surface)
resharper_unused_parameter_global_highlighting = none # public-API parameters can be unused for compat
resharper_unused_member_local_highlighting = error # IDE0051 may not fire at compile time reliably — keep Rider nagging
resharper_unused_member_global_highlighting = suggestion # public-API members may be intentionally exposed
resharper_unused_field_local_highlighting = none # handled by CA1823
resharper_unused_field_global_highlighting = none # public-API fields may be intentionally exposed
resharper_unused_type_local_highlighting = error # IDE0052 may not fire at compile time reliably — keep Rider nagging
resharper_unused_type_global_highlighting = suggestion # public-API types may be intentionally exposed
resharper_unused_variable_highlighting = none # handled by CS0219
resharper_unused_auto_property_accessor_local_highlighting = none # data-class setters are intentional even when unused locally
resharper_unused_auto_property_accessor_global_highlighting = none # public auto-properties may be intentionally exposed

###################
# ReSharper - Code quality (matches CA/RCS semantic analyzers)
###################
resharper_class_never_instantiated_local_highlighting = none # handled by CA1812
resharper_class_never_instantiated_global_highlighting = suggestion # public types may be instantiated externally
resharper_class_cannot_be_instantiated_highlighting = none # handled by CA1052
resharper_class_can_be_sealed_local_highlighting = none # handled by CA1852 (private/internal surface)
resharper_class_can_be_sealed_global_highlighting = none # public types stay open for inheritance
resharper_use_nameof_expression_highlighting = none # handled by CA1507 / RCS1015
resharper_possible_null_reference_exception_highlighting = none # handled bynullability analyzer
resharper_possible_invalid_operation_exception_highlighting = none # handled bynullability analyzer
resharper_possible_multiple_enumeration_highlighting = none # handled by CA1851
resharper_possible_mistaken_argument_null_check_highlighting = none # handled by CA1062
resharper_convert_to_constant_local_highlighting = none # handled by RCS1118
resharper_convert_to_static_class_highlighting = none # handled by CA1052
resharper_convert_to_auto_property_highlighting = none # handled by RCS1085
resharper_convert_to_auto_property_when_possible_highlighting = none # handled by RCS1085
resharper_convert_to_auto_property_with_private_setter_highlighting = none # handled by RCS1085
resharper_auto_property_can_be_made_get_only_local_highlighting = none # handled by RCS1170
resharper_auto_property_can_be_made_get_only_global_highlighting = suggestion # public setters kept for API consumers
resharper_member_can_be_made_static_local_highlighting = none # handled by CA1822 (private/internal surface)
resharper_member_can_be_made_static_global_highlighting = none # public members kept virtual for inheritance
resharper_member_can_be_private_local_highlighting = none # access modifiers are deliberate — don't suggest tightening
resharper_method_has_async_overload_highlighting = none # sync call sites are intentional (e.g. test setup, disposal, sample code)
resharper_member_can_be_private_global_highlighting = none # access modifiers are deliberate — don't suggest tightening
resharper_field_can_be_made_read_only_local_highlighting = none # handled by RCS1169
resharper_field_can_be_made_read_only_global_highlighting = none # handled by RCS1169
resharper_merge_into_pattern_highlighting = none # handled by RCS1220
resharper_merge_conditional_expression_highlighting = none # handled by RCS1173
resharper_merge_sequential_checks_highlighting = none # handled by RCS1206
resharper_simplify_conditional_ternary_expression_highlighting = none # handled by RCS1049 / RCS1104
resharper_simplify_linq_expression_highlighting = error # handled by RCS1077
resharper_string_compare_to_is_culture_specific_highlighting = none # handled by CA1310
resharper_string_ends_with_is_culture_specific_highlighting = none # handled by CA1310
resharper_string_index_of_is_culture_specific_1_highlighting = none # handled by CA1310
resharper_string_index_of_is_culture_specific_2_highlighting = none # handled by CA1310
resharper_string_index_of_is_culture_specific_3_highlighting = none # handled by CA1310
resharper_string_last_index_of_is_culture_specific_1_highlighting = none # handled by CA1310
resharper_string_last_index_of_is_culture_specific_2_highlighting = none # handled by CA1310
resharper_string_last_index_of_is_culture_specific_3_highlighting = none # handled by CA1310
resharper_string_starts_with_is_culture_specific_highlighting = none # handled by CA1310
resharper_specify_a_culture_in_string_conversion_explicitly_highlighting = none # handled by CA1304

###################
# ReSharper - Control flow / nesting
###################
resharper_invert_if_highlighting = suggestion # related to RCS1208 — Rider is more aggressive
resharper_tail_recursive_call_highlighting = suggestion

###################
# ReSharper - Documentation (covered by StyleCop SA1600 family)
###################
resharper_missing_xml_doc_highlighting = none # covered by SA1600 family
resharper_missing_xml_doc_global_highlighting = none # covered by SA1600 family
resharper_invalid_xml_doc_comment_highlighting = none # handled by SA1612 / SA1613

###################
# ReSharper - Typo / spelling (not enforced)
###################
resharper_comment_typo_highlighting = none # typo checks are out of scope
resharper_string_literal_typo_highlighting = none # typo checks are out of scope
resharper_identifier_typo_highlighting = none # typo checks are out of scope
resharper_markup_text_typo_highlighting = none # typo checks are out of scope

#############################################
# Deliberate type-driven registration APIs
#############################################
# These public factory/registration APIs intentionally require callers to select types
# explicitly. SST2307 documents this as a legitimate exception to its inference rule.
[src/Extensions.Hosting.Avalonia/Extensions/AvaloniaBuilderExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.Identity.EntityFrameworkCore.Sqlite/HostBuilderEntityFrameworkCoreExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.Identity.EntityFrameworkCore/HostBuilderEntityFrameworkCoreExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.Maui/HostBuilderMauiExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.Maui/MauiBuilderExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.WinForms/HostBuilderWinFormsExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.WinUI/HostBuilderWinUIExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

[src/Extensions.Hosting.Wpf/WpfBuilderExtensions.cs]
dotnet_diagnostic.SST2307.severity = none

#############################################
# Other Settings
#############################################
vsspell_dictionary_languages = en-US

#############################################
# C++ Files
#############################################
[*.{cpp,h,in}]
curly_bracket_next_line = true
indent_brace_style = Allman

#############################################
# XML Files
#############################################
[*.{csproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}]
indent_size = 2

[*.builds]
indent_size = 2

[*.{xml,stylecop,resx,ruleset}]
indent_size = 2

[*.{props,targets,config,nuspec}]
indent_size = 2

#############################################
# Shell Scripts
#############################################
[*.sh]
end_of_line = lf

[*.{cmd, bat}]
end_of_line = crlf

#############################################
# Test projects (TUnit)
#############################################
# TUnit instantiates test classes per test, so they must remain instance classes and
# cannot be marked static — even when a partial declaration happens to hold only static
# members (the instance [Test] methods live in sibling partial files).