Add option for analyzer RCS1146 (#1688)

josefpihrt · web-flow · commit feade75a60af · 2025-11-22T21:49:04.000+01:00
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add option `roslynator_null_conditional_operator.avoid_negative_boolean_comparison` ([PR](https://github.com/dotnet/roslynator/pull/1688))
+  - Do not suggest to use null-conditional operator when result would be `... != true/false`
+  - Applicable for [RCS1146](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1146)
+
 ### Fixed
 
 - Fix analyzer [RCS1172](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1172) ([PR](https://github.com/dotnet/roslynator/pull/1710))
diff --git a/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseConditionalAccessCodeFixProvider.cs b/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseConditionalAccessCodeFixProvider.cs
@@ -79,11 +79,11 @@ private static async Task<Document> UseConditionalAccessAsync(
     {
         SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-        SyntaxKind kind = binaryExpression.Kind();
+        SyntaxKind binaryExpressionKind = binaryExpression.Kind();
 
-        (ExpressionSyntax left, ExpressionSyntax right) = UseConditionalAccessAnalyzer.GetFixableExpressions(binaryExpression, kind, semanticModel, cancellationToken);
+        (ExpressionSyntax left, ExpressionSyntax right) = UseConditionalAccessAnalyzer.GetFixableExpressions(binaryExpression, binaryExpressionKind, semanticModel, cancellationToken);
 
-        NullCheckStyles allowedStyles = (kind == SyntaxKind.LogicalAndExpression)
+        NullCheckStyles allowedStyles = (binaryExpressionKind == SyntaxKind.LogicalAndExpression)
             ? (NullCheckStyles.NotEqualsToNull | NullCheckStyles.IsNotNull)
             : (NullCheckStyles.EqualsToNull | NullCheckStyles.IsNull);
 
@@ -134,12 +134,12 @@ private static async Task<Document> UseConditionalAccessAsync(
             }
             case SyntaxKind.LogicalNotExpression:
             {
-                builder.Append((kind == SyntaxKind.LogicalAndExpression) ? " == false" : " != true");
+                builder.Append((binaryExpressionKind == SyntaxKind.LogicalAndExpression) ? " == false" : " != true");
                 break;
             }
             default:
             {
-                builder.Append((kind == SyntaxKind.LogicalAndExpression) ? " == true" : " != false");
+                builder.Append((binaryExpressionKind == SyntaxKind.LogicalAndExpression) ? " == true" : " != false");
                 break;
             }
         }
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
@@ -4484,6 +4484,9 @@ string s2 = s as string;]]></Before>
     <DefaultSeverity>Info</DefaultSeverity>
     <IsEnabledByDefault>true</IsEnabledByDefault>
     <MinLanguageVersion>6.0</MinLanguageVersion>
+    <ConfigOptions>
+      <Option Key="null_conditional_operator.avoid_negative_boolean_comparison" />
+    </ConfigOptions>
     <Samples>
       <Sample>
         <Before><![CDATA[if (s != null && s.StartsWith("a"))
diff --git a/src/Analyzers/CSharp/Analysis/UseConditionalAccessAnalyzer.cs b/src/Analyzers/CSharp/Analysis/UseConditionalAccessAnalyzer.cs
@@ -126,6 +126,12 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
         if (left is null)
             return;
 
+        if (context.GetConfigOptions().AvoidNegativeBooleanComparison()
+            && WillBeConvertedToNegativeBooleanComparison(binaryExpression, right))
+        {
+            return;
+        }
+
         ISymbol operatorSymbol = context.SemanticModel.GetSymbol(binaryExpression, context.CancellationToken);
 
         if (operatorSymbol?.Name == WellKnownMemberNames.BitwiseOrOperatorName)
@@ -456,4 +462,32 @@ bool IsFirstChild(SyntaxNode node)
             return true;
         }
     }
+
+    private static bool WillBeConvertedToNegativeBooleanComparison(ExpressionSyntax binaryExpression, ExpressionSyntax rightExpression)
+    {
+        switch (rightExpression.Kind())
+        {
+            case SyntaxKind.LogicalOrExpression:
+            case SyntaxKind.LogicalAndExpression:
+            case SyntaxKind.BitwiseOrExpression:
+            case SyntaxKind.BitwiseAndExpression:
+            case SyntaxKind.ExclusiveOrExpression:
+            case SyntaxKind.EqualsExpression:
+            case SyntaxKind.NotEqualsExpression:
+            case SyntaxKind.LessThanExpression:
+            case SyntaxKind.LessThanOrEqualExpression:
+            case SyntaxKind.GreaterThanExpression:
+            case SyntaxKind.GreaterThanOrEqualExpression:
+            case SyntaxKind.IsExpression:
+            case SyntaxKind.AsExpression:
+            case SyntaxKind.IsPatternExpression:
+            {
+                return false;
+            }
+            default:
+            {
+                return binaryExpression.IsKind(SyntaxKind.LogicalOrExpression);
+            }
+        }
+    }
 }
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -621,4 +621,9 @@ private static bool TryGetNewLinePosition(
         newLinePosition = NewLinePosition.None;
         return false;
     }
+
+    public static bool AvoidNegativeBooleanComparison(this AnalyzerConfigOptions configOptions)
+    {
+        return ConfigOptions.TryGetValueAsBool(configOptions, ConfigOptions.NullConditionalOperator_AvoidNegativeBooleanComparison, out bool value) && value;
+    }
 }
diff --git a/src/Common/ConfigOptionKeys.Generated.cs b/src/Common/ConfigOptionKeys.Generated.cs
@@ -6,44 +6,45 @@ namespace Roslynator
 {
     internal static partial class ConfigOptionKeys
     {
-        public const string AccessibilityModifiers                            = "roslynator_accessibility_modifiers";
-        public const string AccessorBracesStyle                               = "roslynator_accessor_braces_style";
-        public const string ArrayCreationTypeStyle                            = "roslynator_array_creation_type_style";
-        public const string ArrowTokenNewLine                                 = "roslynator_arrow_token_new_line";
-        public const string BinaryOperatorNewLine                             = "roslynator_binary_operator_new_line";
-        public const string BlankLineAfterFileScopedNamespaceDeclaration      = "roslynator_blank_line_after_file_scoped_namespace_declaration";
-        public const string BlankLineBetweenClosingBraceAndSwitchSection      = "roslynator_blank_line_between_closing_brace_and_switch_section";
-        public const string BlankLineBetweenSingleLineAccessors               = "roslynator_blank_line_between_single_line_accessors";
-        public const string BlankLineBetweenSwitchSections                    = "roslynator_blank_line_between_switch_sections";
-        public const string BlankLineBetweenUsingDirectives                   = "roslynator_blank_line_between_using_directives";
-        public const string BlockBracesStyle                                  = "roslynator_block_braces_style";
-        public const string BodyStyle                                         = "roslynator_body_style";
-        public const string ConditionalOperatorConditionParenthesesStyle      = "roslynator_conditional_operator_condition_parentheses_style";
-        public const string ConditionalOperatorNewLine                        = "roslynator_conditional_operator_new_line";
-        public const string ConfigureAwait                                    = "roslynator_configure_await";
-        public const string DocCommentSummaryStyle                            = "roslynator_doc_comment_summary_style";
-        public const string EmptyStringStyle                                  = "roslynator_empty_string_style";
-        public const string EnumFlagValueStyle                                = "roslynator_enum_flag_value_style";
-        public const string EnumHasFlagStyle                                  = "roslynator_enum_has_flag_style";
-        public const string EqualsTokenNewLine                                = "roslynator_equals_token_new_line";
-        public const string InfiniteLoopStyle                                 = "roslynator_infinite_loop_style";
-        public const string MaxLineLength                                     = "roslynator_max_line_length";
-        public const string NewLineAtEndOfFile                                = "roslynator_new_line_at_end_of_file";
-        public const string NewLineBeforeWhileInDoStatement                   = "roslynator_new_line_before_while_in_do_statement";
-        public const string NullCheckStyle                                    = "roslynator_null_check_style";
-        public const string NullConditionalOperatorNewLine                    = "roslynator_null_conditional_operator_new_line";
-        public const string ObjectCreationParenthesesStyle                    = "roslynator_object_creation_parentheses_style";
-        public const string ObjectCreationTypeStyle                           = "roslynator_object_creation_type_style";
-        public const string PrefixFieldIdentifierWithUnderscore               = "roslynator_prefix_field_identifier_with_underscore";
-        public const string SuppressUnityScriptMethods                        = "roslynator_suppress_unity_script_methods";
-        public const string TabLength                                         = "roslynator_tab_length";
-        public const string TrailingCommaStyle                                = "roslynator_trailing_comma_style";
-        public const string UnityCodeAnalysisEnabled                          = "roslynator_unity_code_analysis.enabled";
-        public const string UseAnonymousFunctionOrMethodGroup                 = "roslynator_use_anonymous_function_or_method_group";
-        public const string UseBlockBodyWhenDeclarationSpansOverMultipleLines = "roslynator_use_block_body_when_declaration_spans_over_multiple_lines";
-        public const string UseBlockBodyWhenExpressionSpansOverMultipleLines  = "roslynator_use_block_body_when_expression_spans_over_multiple_lines";
-        public const string UseCollectionExpression                           = "roslynator_use_collection_expression";
-        public const string UseVar                                            = "roslynator_use_var";
-        public const string UseVarInsteadOfImplicitObjectCreation             = "roslynator_use_var_instead_of_implicit_object_creation";
+        public const string AccessibilityModifiers                                 = "roslynator_accessibility_modifiers";
+        public const string AccessorBracesStyle                                    = "roslynator_accessor_braces_style";
+        public const string ArrayCreationTypeStyle                                 = "roslynator_array_creation_type_style";
+        public const string ArrowTokenNewLine                                      = "roslynator_arrow_token_new_line";
+        public const string BinaryOperatorNewLine                                  = "roslynator_binary_operator_new_line";
+        public const string BlankLineAfterFileScopedNamespaceDeclaration           = "roslynator_blank_line_after_file_scoped_namespace_declaration";
+        public const string BlankLineBetweenClosingBraceAndSwitchSection           = "roslynator_blank_line_between_closing_brace_and_switch_section";
+        public const string BlankLineBetweenSingleLineAccessors                    = "roslynator_blank_line_between_single_line_accessors";
+        public const string BlankLineBetweenSwitchSections                         = "roslynator_blank_line_between_switch_sections";
+        public const string BlankLineBetweenUsingDirectives                        = "roslynator_blank_line_between_using_directives";
+        public const string BlockBracesStyle                                       = "roslynator_block_braces_style";
+        public const string BodyStyle                                              = "roslynator_body_style";
+        public const string ConditionalOperatorConditionParenthesesStyle           = "roslynator_conditional_operator_condition_parentheses_style";
+        public const string ConditionalOperatorNewLine                             = "roslynator_conditional_operator_new_line";
+        public const string ConfigureAwait                                         = "roslynator_configure_await";
+        public const string DocCommentSummaryStyle                                 = "roslynator_doc_comment_summary_style";
+        public const string EmptyStringStyle                                       = "roslynator_empty_string_style";
+        public const string EnumFlagValueStyle                                     = "roslynator_enum_flag_value_style";
+        public const string EnumHasFlagStyle                                       = "roslynator_enum_has_flag_style";
+        public const string EqualsTokenNewLine                                     = "roslynator_equals_token_new_line";
+        public const string InfiniteLoopStyle                                      = "roslynator_infinite_loop_style";
+        public const string MaxLineLength                                          = "roslynator_max_line_length";
+        public const string NewLineAtEndOfFile                                     = "roslynator_new_line_at_end_of_file";
+        public const string NewLineBeforeWhileInDoStatement                        = "roslynator_new_line_before_while_in_do_statement";
+        public const string NullCheckStyle                                         = "roslynator_null_check_style";
+        public const string NullConditionalOperator_AvoidNegativeBooleanComparison = "roslynator_null_conditional_operator.avoid_negative_boolean_comparison";
+        public const string NullConditionalOperatorNewLine                         = "roslynator_null_conditional_operator_new_line";
+        public const string ObjectCreationParenthesesStyle                         = "roslynator_object_creation_parentheses_style";
+        public const string ObjectCreationTypeStyle                                = "roslynator_object_creation_type_style";
+        public const string PrefixFieldIdentifierWithUnderscore                    = "roslynator_prefix_field_identifier_with_underscore";
+        public const string SuppressUnityScriptMethods                             = "roslynator_suppress_unity_script_methods";
+        public const string TabLength                                              = "roslynator_tab_length";
+        public const string TrailingCommaStyle                                     = "roslynator_trailing_comma_style";
+        public const string UnityCodeAnalysisEnabled                               = "roslynator_unity_code_analysis.enabled";
+        public const string UseAnonymousFunctionOrMethodGroup                      = "roslynator_use_anonymous_function_or_method_group";
+        public const string UseBlockBodyWhenDeclarationSpansOverMultipleLines      = "roslynator_use_block_body_when_declaration_spans_over_multiple_lines";
+        public const string UseBlockBodyWhenExpressionSpansOverMultipleLines       = "roslynator_use_block_body_when_expression_spans_over_multiple_lines";
+        public const string UseCollectionExpression                                = "roslynator_use_collection_expression";
+        public const string UseVar                                                 = "roslynator_use_var";
+        public const string UseVarInsteadOfImplicitObjectCreation                  = "roslynator_use_var_instead_of_implicit_object_creation";
     }
 }
diff --git a/src/Common/ConfigOptions.Generated.cs b/src/Common/ConfigOptions.Generated.cs
@@ -159,6 +159,12 @@ public static partial class ConfigOptions
             defaultValuePlaceholder: "equality_operator|pattern_matching", 
             description:             "Use equality operator or pattern matching as a null check");
 
+        public static readonly ConfigOptionDescriptor NullConditionalOperator_AvoidNegativeBooleanComparison = new(
+            key:                     ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, 
+            defaultValue:            "false", 
+            defaultValuePlaceholder: "true|false", 
+            description:             "Do not suggest to use null-conditional operator when result would be `... != true/false`");
+
         public static readonly ConfigOptionDescriptor NullConditionalOperatorNewLine = new(
             key:                     ConfigOptionKeys.NullConditionalOperatorNewLine, 
             defaultValue:            null, 
diff --git a/src/ConfigOptions.xml b/src/ConfigOptions.xml
@@ -237,6 +237,12 @@
       <Value>when_type_is_obvious</Value>
     </Values>
   </Option>
+    <Option Id="NullConditionalOperator_AvoidNegativeBooleanComparison">
+        <Key>null_conditional_operator.avoid_negative_boolean_comparison</Key>
+        <DefaultValue>false</DefaultValue>
+        <ValuePlaceholder>true|false</ValuePlaceholder>
+        <Description>Do not suggest to use null-conditional operator when result would be `... != true/false`</Description>
+    </Option>
   <!--
   <Option Id="">
     <Key></Key>
diff --git a/src/Tests/Analyzers.Tests/RCS1146UseConditionalAccessTests.cs b/src/Tests/Analyzers.Tests/RCS1146UseConditionalAccessTests.cs
@@ -209,7 +209,7 @@ void M()
             && f) { }
     }
 }
-""");
+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -235,7 +235,7 @@ void M()
         if (x?.Equals(x) == false) { }
     }
 }
-");
+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -319,7 +319,7 @@ void M()
         if (dic?[0].Equals("x") == false) { }
     }
 }
-""");
+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -363,7 +363,7 @@ Foo M()
     Foo M2() => null;
     Foo M3() => null;
 }
-");
+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -429,7 +429,7 @@ void M()
         if (x?.ToString()?.ToString() != null) { }
     }
 }
-""");
+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -488,7 +488,7 @@ void M()
         if (x?.ToString()?.ToString()?.ToString() != null) { }
     }
 }
-");
+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -527,7 +527,7 @@ void M()
         if (x != null && (x.P != null) is object _) { }
     }
 }
-""");
+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
@@ -983,4 +983,42 @@ void M()
 }
 ");
     }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]
+    public async Task Test_AvoidNegativeBooleanComparison()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class Foo
+{
+    void M1()
+    {
+        Foo x = null;
+
+        if (x == null || x.Equals(x)) { }
+
+        if (x == default(Foo) || x.Equals(x)) { }
+
+        if (x == default || x.Equals(x)) { }
+
+        if (x == null || (x.Equals(x))) { }
+
+        if (x == null || !x.Equals(x)) { }
+
+        if (x == null || (!x.Equals(x))) { }
+    }
+}
+
+struct Foo2
+{
+    void M()
+    {
+        Foo2? x = null;
+
+        if (x == null || x.Value.Equals(x)) { }
+
+        if (x == null || !x.Value.Equals(x)) { }
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));
+    }
 }
diff --git a/src/Tools/CodeGeneration/CodeGeneration.csproj b/src/Tools/CodeGeneration/CodeGeneration.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/src/Tools/CodeGeneration/EditorConfig/EditorConfigGenerator.cs b/src/Tools/CodeGeneration/EditorConfig/EditorConfigGenerator.cs
@@ -79,7 +79,7 @@ public static string GenerateEditorConfig(RoslynatorMetadata metadata, bool comm
                 w.WriteAnalyzer(
                     analyzer.Id.ToLowerInvariant(),
                     (analyzer.IsEnabledByDefault)
-                        ? ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), analyzer.DefaultSeverity)).ToReportDiagnostic()
+                        ? Enum.Parse<DiagnosticSeverity>(analyzer.DefaultSeverity).ToReportDiagnostic()
                         : ReportDiagnostic.Suppress);
 
                 if (analyzer.ConfigOptions.Count > 0)
diff --git a/src/Tools/CodeGenerator/CodeGenerator.csproj b/src/Tools/CodeGenerator/CodeGenerator.csproj
diff --git a/src/Tools/ConfigurationFileGenerator/ConfigurationFileGenerator.csproj b/src/Tools/ConfigurationFileGenerator/ConfigurationFileGenerator.csproj
diff --git a/src/Tools/Metadata/Metadata.csproj b/src/Tools/Metadata/Metadata.csproj
diff --git a/src/Tools/MetadataGenerator/MetadataGenerator.csproj b/src/Tools/MetadataGenerator/MetadataGenerator.csproj
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts

Original file line number	Diff line number	Diff line change
`@@ -79,11 +79,11 @@ private static async Task<Document> UseConditionalAccessAsync(`
`79`	`79`	`{`
`80`	`80`	`SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);`
`81`	`81`
`82`		`- SyntaxKind kind = binaryExpression.Kind();`
	`82`	`+ SyntaxKind binaryExpressionKind = binaryExpression.Kind();`
`83`	`83`
`84`		`- (ExpressionSyntax left, ExpressionSyntax right) = UseConditionalAccessAnalyzer.GetFixableExpressions(binaryExpression, kind, semanticModel, cancellationToken);`
	`84`	`+ (ExpressionSyntax left, ExpressionSyntax right) = UseConditionalAccessAnalyzer.GetFixableExpressions(binaryExpression, binaryExpressionKind, semanticModel, cancellationToken);`
`85`	`85`
`86`		`- NullCheckStyles allowedStyles = (kind == SyntaxKind.LogicalAndExpression)`
	`86`	`+ NullCheckStyles allowedStyles = (binaryExpressionKind == SyntaxKind.LogicalAndExpression)`
`87`	`87`	`? (NullCheckStyles.NotEqualsToNull \| NullCheckStyles.IsNotNull)`
`88`	`88`	`: (NullCheckStyles.EqualsToNull \| NullCheckStyles.IsNull);`
`89`	`89`
`@@ -134,12 +134,12 @@ private static async Task<Document> UseConditionalAccessAsync(`
`134`	`134`	`}`
`135`	`135`	`case SyntaxKind.LogicalNotExpression:`
`136`	`136`	`{`
`137`		`- builder.Append((kind == SyntaxKind.LogicalAndExpression) ? " == false" : " != true");`
	`137`	`+ builder.Append((binaryExpressionKind == SyntaxKind.LogicalAndExpression) ? " == false" : " != true");`
`138`	`138`	`break;`
`139`	`139`	`}`
`140`	`140`	`default:`
`141`	`141`	`{`
`142`		`- builder.Append((kind == SyntaxKind.LogicalAndExpression) ? " == true" : " != false");`
	`142`	`+ builder.Append((binaryExpressionKind == SyntaxKind.LogicalAndExpression) ? " == true" : " != false");`
`143`	`143`	`break;`
`144`	`144`	`}`
`145`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -621,4 +621,9 @@ private static bool TryGetNewLinePosition(`
`621`	`621`	`newLinePosition = NewLinePosition.None;`
`622`	`622`	`return false;`
`623`	`623`	`}`
	`624`	`+`
	`625`	`+ public static bool AvoidNegativeBooleanComparison(this AnalyzerConfigOptions configOptions)`
	`626`	`+ {`
	`627`	`+ return ConfigOptions.TryGetValueAsBool(configOptions, ConfigOptions.NullConditionalOperator_AvoidNegativeBooleanComparison, out bool value) && value;`
	`628`	`+ }`
`624`	`629`	`}`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ void M()`
`209`	`209`	`&& f) { }`
`210`	`210`	`}`
`211`	`211`	`}`
`212`		`-""");`
	`212`	`+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -235,7 +235,7 @@ void M()`
`235`	`235`	`if (x?.Equals(x) == false) { }`
`236`	`236`	`}`
`237`	`237`	`}`
`238`		`-");`
	`238`	`+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -319,7 +319,7 @@ void M()`
`319`	`319`	`if (dic?[0].Equals("x") == false) { }`
`320`	`320`	`}`
`321`	`321`	`}`
`322`		`-""");`
	`322`	`+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -363,7 +363,7 @@ Foo M()`
`363`	`363`	`Foo M2() => null;`
`364`	`364`	`Foo M3() => null;`
`365`	`365`	`}`
`366`		`-");`
	`366`	`+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -429,7 +429,7 @@ void M()`
`429`	`429`	`if (x?.ToString()?.ToString() != null) { }`
`430`	`430`	`}`
`431`	`431`	`}`
`432`		`-""");`
	`432`	`+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`433`	`433`	`}`
`434`	`434`
`435`	`435`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -488,7 +488,7 @@ void M()`
`488`	`488`	`if (x?.ToString()?.ToString()?.ToString() != null) { }`
`489`	`489`	`}`
`490`	`490`	`}`
`491`		`-");`
	`491`	`+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`492`	`492`	`}`
`493`	`493`
`494`	`494`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -527,7 +527,7 @@ void M()`
`527`	`527`	`if (x != null && (x.P != null) is object _) { }`
`528`	`528`	`}`
`529`	`529`	`}`
`530`		`-""");`
	`530`	`+""", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
`531`	`531`	`}`
`532`	`532`
`533`	`533`	`[Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
`@@ -983,4 +983,42 @@ void M()`
`983`	`983`	`}`
`984`	`984`	`");`
`985`	`985`	`}`
	`986`	`+`
	`987`	`+ [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseConditionalAccess)]`
	`988`	`+ public async Task Test_AvoidNegativeBooleanComparison()`
	`989`	`+ {`
	`990`	`+ await VerifyNoDiagnosticAsync(@"`
	`991`	`+class Foo`
	`992`	`+{`
	`993`	`+ void M1()`
	`994`	`+ {`
	`995`	`+ Foo x = null;`
	`996`	`+`
	`997`	`+ if (x == null \|\| x.Equals(x)) { }`
	`998`	`+`
	`999`	`+ if (x == default(Foo) \|\| x.Equals(x)) { }`
	`1000`	`+`
	`1001`	`+ if (x == default \|\| x.Equals(x)) { }`
	`1002`	`+`
	`1003`	`+ if (x == null \|\| (x.Equals(x))) { }`
	`1004`	`+`
	`1005`	`+ if (x == null \|\| !x.Equals(x)) { }`
	`1006`	`+`
	`1007`	`+ if (x == null \|\| (!x.Equals(x))) { }`
	`1008`	`+ }`
	`1009`	`+}`
	`1010`	`+`
	`1011`	`+struct Foo2`
	`1012`	`+{`
	`1013`	`+ void M()`
	`1014`	`+ {`
	`1015`	`+ Foo2? x = null;`
	`1016`	`+`
	`1017`	`+ if (x == null \|\| x.Value.Equals(x)) { }`
	`1018`	`+`
	`1019`	`+ if (x == null \|\| !x.Value.Equals(x)) { }`
	`1020`	`+ }`
	`1021`	`+}`
	`1022`	`+", options: Options.AddConfigOption(ConfigOptionKeys.NullConditionalOperator_AvoidNegativeBooleanComparison, true));`
	`1023`	`+ }`
`986`	`1024`	`}`