Simplify code with patterns. (#81876)

CyrusNajmabadi · web-flow · commit 54fa1a6bbd4a · 2026-01-07T09:43:47.000-05:00
diff --git a/src/Analyzers/Core/CodeFixes/AddParameter/AbstractAddParameterCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/AddParameter/AbstractAddParameterCodeFixProvider.cs
@@ -481,7 +481,7 @@ private async Task<Solution> FixAsync(
                 var isNullLiteral = syntaxFacts.IsNullLiteralExpression(expressionOfArgument);
                 var isDefaultLiteral = syntaxFacts.IsDefaultLiteralExpression(expressionOfArgument);
 
-                if (argumentTypeInfo.Type == null && argumentTypeInfo.ConvertedType == null)
+                if (argumentTypeInfo is { Type: null, ConvertedType: null })
                 {
                     // Didn't know the type of the argument.  We shouldn't assume it doesn't
                     // match a parameter.  However, if the user wrote 'null' and it didn't
diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler_Helpers.cs
@@ -243,7 +243,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) AddBraceToIfStatement
         //     $$
         // }
         // Print();
-        if (ifStatementNode.Else == null && ifStatementNode.Parent is BlockSyntax)
+        if (ifStatementNode is { Else: null, Parent: BlockSyntax })
         {
             return ReplaceStatementOwnerAndInsertStatement(
                 services,
diff --git a/src/EditorFeatures/Core/IntelliSense/AsyncCompletion/CompletionSource.cs b/src/EditorFeatures/Core/IntelliSense/AsyncCompletion/CompletionSource.cs
@@ -158,7 +158,7 @@ private bool ShouldTriggerCompletion(
         //The user may be trying to invoke snippets through question-tab.
         // We may provide a completion after that.
         // Otherwise, tab should not be a completion trigger.
-        if (trigger.Reason == AsyncCompletionData.CompletionTriggerReason.Insertion && trigger.Character == '\t')
+        if (trigger is { Reason: AsyncCompletionData.CompletionTriggerReason.Insertion, Character: '\t' })
         {
             return TryInvokeSnippetCompletion(triggerLocation.Snapshot.TextBuffer, triggerLocation.Position, sourceText, document.Project.Services, completionService.GetRules(options));
         }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
@@ -111,8 +111,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,
                     addEqualsAndQuotes: !nextToken.IsKind(SyntaxKind.EqualsToken) || nextToken.HasLeadingTrivia);
             }
 
-            var wasTriggeredAfterSpace = trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character == ' ';
-            if (wasTriggeredAfterSpace)
+            if (trigger is { Kind: CompletionTriggerKind.Insertion, Character: ' ' })
             {
                 // Nothing below this point should triggered by a space character
                 // (only attribute names should be triggered by <SPACE>)
@@ -124,7 +123,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,
                 return GetAttributeValueItems(declaredSymbol, elementName, attributeName);
             }
 
-            if (trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character != '<')
+            if (trigger is { Kind: CompletionTriggerKind.Insertion, Character: not '<' })
             {
                 // With the use of IsTriggerAfterSpaceOrStartOfWordCharacter, the code below is much
                 // too aggressive at suggesting tags, so exit early before degrading the experience
diff --git a/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs b/src/Features/CSharp/Portable/EditAndContinue/SyntaxComparer.cs
@@ -1082,8 +1082,8 @@ private bool TryComputeWeightedDistance(BlockSyntax leftBlock, BlockSyntax right
             case SyntaxKind.CatchClause:
                 var leftCatch = (CatchClauseSyntax)leftBlock.Parent;
                 var rightCatch = (CatchClauseSyntax)rightBlock.Parent;
-                if (leftCatch.Declaration == null && leftCatch.Filter == null &&
-                    rightCatch.Declaration == null && rightCatch.Filter == null)
+                if (leftCatch is { Declaration: null, Filter: null } &&
+                    rightCatch is { Declaration: null, Filter: null })
                 {
                     var leftTry = (TryStatementSyntax)leftCatch.Parent!;
                     var rightTry = (TryStatementSyntax)rightCatch.Parent!;
diff --git a/src/Features/CSharp/Portable/EditAndContinue/SyntaxUtilities.cs b/src/Features/CSharp/Portable/EditAndContinue/SyntaxUtilities.cs
@@ -197,7 +197,7 @@ public static bool HasBackingField(PropertyDeclarationSyntax property)
         }
 
         return property.ExpressionBody == null
-            && property.AccessorList!.Accessors.Any(e => e.Body == null && e.ExpressionBody == null);
+            && property.AccessorList!.Accessors.Any(e => e is { Body: null, ExpressionBody: null });
     }
 
     /// <summary>
diff --git a/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/UseNamedArguments/CSharpUseNamedArgumentsCodeRefactoringProvider.cs
@@ -81,7 +81,7 @@ private sealed class AttributeArgumentAnalyzer :
         BaseAnalyzer<AttributeArgumentSyntax, AttributeArgumentListSyntax>
     {
         protected override bool IsPositionalArgument(AttributeArgumentSyntax argument)
-            => argument.NameColon == null && argument.NameEquals == null;
+            => argument is { NameColon: null, NameEquals: null };
 
         protected override SeparatedSyntaxList<AttributeArgumentSyntax> GetArguments(AttributeArgumentListSyntax argumentList)
             => argumentList.Arguments;
diff --git a/src/Features/Core/Portable/Completion/CompletionService.cs b/src/Features/Core/Portable/Completion/CompletionService.cs
@@ -146,15 +146,11 @@ internal virtual bool ShouldTriggerCompletion(
             return false;
 
         // Enter does not trigger completion.
-        if (trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character == '\n')
-        {
+        if (trigger is { Kind: CompletionTriggerKind.Insertion, Character: '\n' })
             return false;
-        }
 
         if (trigger.Kind == CompletionTriggerKind.Deletion && SupportsTriggerOnDeletion(options))
-        {
             return char.IsLetterOrDigit(trigger.Character) || trigger.Character == '.';
-        }
 
         var extensionManager = languageServices.SolutionServices.GetRequiredService<IExtensionManager>();
 
diff --git a/src/Features/Core/Portable/Diagnostics/Service/DiagnosticAnalyzerService_DeprioritizationCandidates.cs b/src/Features/Core/Portable/Diagnostics/Service/DiagnosticAnalyzerService_DeprioritizationCandidates.cs
@@ -99,7 +99,7 @@ public async Task<bool> IsAnyDeprioritizedDiagnosticIdInProcessAsync(
             if (telemetryInfo == null)
                 return null;
 
-            if (telemetryInfo.SymbolStartActionsCount == 0 && telemetryInfo.SemanticModelActionsCount == 0)
+            if (telemetryInfo is { SymbolStartActionsCount: 0, SemanticModelActionsCount: 0 })
                 return null;
 
             return [.. analyzer.SupportedDiagnostics.Select(d => d.Id)];
diff --git a/src/Features/Core/Portable/EditAndContinue/EditSession.cs b/src/Features/Core/Portable/EditAndContinue/EditSession.cs
@@ -983,7 +983,7 @@ private static void ResolveSymbols(
                 newResolution = edit.Symbol.Resolve(newCompilation, cancellationToken: cancellationToken);
                 Contract.ThrowIfNull(newResolution.Symbol);
             }
-            else if (edit.Kind == SemanticEditKind.Delete && edit.DeletedSymbolContainer is not null)
+            else if (edit is { Kind: SemanticEditKind.Delete, DeletedSymbolContainer: not null })
             {
                 // For deletes, we use NewSymbol to reference the containing type of the deleted member
                 newResolution = edit.DeletedSymbolContainer.Value.Resolve(newCompilation, cancellationToken: cancellationToken);
diff --git a/src/Features/Core/Portable/LanguageServiceIndexFormat/SymbolMoniker.cs b/src/Features/Core/Portable/LanguageServiceIndexFormat/SymbolMoniker.cs
@@ -30,12 +30,12 @@ SymbolKind.Label or
 
         // Don't create monikers for built in-operators. We could pick some sort of moniker for these, but I doubt anybody really needs to search for all uses of
         // + in the world's projects at once.
-        if (symbol is IMethodSymbol method && method.MethodKind == MethodKind.BuiltinOperator)
+        if (symbol is IMethodSymbol { MethodKind: MethodKind.BuiltinOperator })
             return false;
 
         // TODO: some symbols for things some things in crefs don't have a ContainingAssembly. We'll skip those for now but do
         // want those to work.
-        if (symbol.Kind != SymbolKind.Namespace && symbol.ContainingAssembly == null)
+        if (symbol is { Kind: not SymbolKind.Namespace, ContainingAssembly: null })
             return false;
 
         return true;
diff --git a/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs b/src/Features/TestUtilities/EditAndContinue/EditAndContinueTestVerifier.cs
@@ -276,7 +276,7 @@ internal void VerifySemantics(
         }
 
         var duplicateNonPartial = allEdits
-            .Where(e => e.PartialType == null && e.DeletedSymbolContainer is null)
+            .Where(e => e is { PartialType: null, DeletedSymbolContainer: null })
             .GroupBy(e => e.Symbol, SymbolKey.GetComparer(ignoreCase: false, ignoreAssemblyKeys: true))
             .Where(g => g.Count() > 1)
             .Select(g => g.Key);
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServer/Handler/DebugConfiguration/WorkspaceDebugConfigurationHandler.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServer/Handler/DebugConfiguration/WorkspaceDebugConfigurationHandler.cs
@@ -33,7 +33,7 @@ public async Task<ProjectDebugConfiguration[]> HandleRequestAsync(WorkspaceDebug
         Contract.ThrowIfNull(context.Solution, nameof(context.Solution));
 
         var projects = context.Solution.Projects
-            .Where(p => p.FilePath != null && p.OutputFilePath != null)
+            .Where(p => p is { FilePath: not null, OutputFilePath: not null })
             .Where(p => IsProjectInWorkspace(request.WorkspacePath, p))
             .Select(GetProjectDebugConfiguration).ToArray();
         return projects;
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs
@@ -50,7 +50,7 @@ protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifi
 
     protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(VSInternalDocumentDiagnosticsParams diagnosticsParams)
     {
-        if (diagnosticsParams.PreviousResultId != null && diagnosticsParams.TextDocument != null)
+        if (diagnosticsParams is { PreviousResultId: not null, TextDocument: not null })
         {
             return ImmutableArray.Create(new PreviousPullResult(diagnosticsParams.PreviousResultId, diagnosticsParams.TextDocument));
         }
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs
@@ -79,7 +79,7 @@ protected override DocumentDiagnosticReport CreateReturn(BufferedProgress<Docume
 
     protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(DocumentDiagnosticParams diagnosticsParams)
     {
-        if (diagnosticsParams.PreviousResultId != null && diagnosticsParams.TextDocument != null)
+        if (diagnosticsParams is { PreviousResultId: not null, TextDocument: not null })
         {
             return ImmutableArray.Create(new PreviousPullResult(diagnosticsParams.PreviousResultId, diagnosticsParams.TextDocument));
         }
diff --git a/src/LanguageServer/Protocol/Handler/SpellCheck/DocumentSpellCheckHandler.cs b/src/LanguageServer/Protocol/Handler/SpellCheck/DocumentSpellCheckHandler.cs
@@ -23,7 +23,7 @@ protected override VSInternalSpellCheckableRangeReport CreateReport(TextDocument
 
     protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(VSInternalDocumentSpellCheckableParams requestParams)
     {
-        if (requestParams.PreviousResultId != null && requestParams.TextDocument != null)
+        if (requestParams is { PreviousResultId: not null, TextDocument: not null })
         {
             return ImmutableArray.Create(new PreviousPullResult(requestParams.PreviousResultId, requestParams.TextDocument));
         }
diff --git a/src/LanguageServer/Protocol/Protocol/Internal/Efficiency/OptimizedVSCompletionListJsonConverter.cs b/src/LanguageServer/Protocol/Protocol/Internal/Efficiency/OptimizedVSCompletionListJsonConverter.cs
@@ -190,7 +190,7 @@ private static void WriteCompletionItem(Utf8JsonWriter writer, CompletionItem co
             writer.WriteString("insertText", completionItem.InsertText);
         }
 
-        if (completionItem.InsertTextFormat != default && completionItem.InsertTextFormat != InsertTextFormat.Plaintext)
+        if (completionItem.InsertTextFormat is not 0 and not InsertTextFormat.Plaintext)
         {
             writer.WriteNumber("insertTextFormat", (int)completionItem.InsertTextFormat);
         }
diff --git a/src/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs b/src/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs
@@ -229,7 +229,7 @@ internal sealed class TestAdditionalFileDocumentSourceProvider() : IDiagnosticSo
 
         async ValueTask<ImmutableArray<IDiagnosticSource>> IDiagnosticSourceProvider.CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
         {
-            if (context.TextDocument is not null && context.TextDocument is not Document)
+            if (context.TextDocument is not null and not Document)
             {
                 return [new TestAdditionalFileDocumentSource(context.TextDocument)];
             }
diff --git a/src/RoslynAnalyzers/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs b/src/RoslynAnalyzers/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs
@@ -76,7 +76,7 @@ private static void AnalyzeAllowedIdsInfoList(
 
             var foundMatch = false;
             static bool ShouldValidateRange((string? prefix, int start, int end) range)
-                => range.start >= 0 && range.end >= 0;
+                => range is { start: >= 0, end: >= 0 };
 
             // Check if ID matches any one of the required ranges.
             foreach (var allowedIds in allowedIdsInfoList)
diff --git a/src/RoslynAnalyzers/PerformanceSensitiveAnalyzers/CSharp/Analyzers/DisplayClassAllocationAnalyzer.cs b/src/RoslynAnalyzers/PerformanceSensitiveAnalyzers/CSharp/Analyzers/DisplayClassAllocationAnalyzer.cs
@@ -93,7 +93,7 @@ private static void ClosureCaptureDataFlowAnalysis(DataFlowAnalysis? flow, Actio
 
             foreach (var capture in flow.Captured)
             {
-                if (capture.Name != null && capture.Locations != null)
+                if (capture is { Name: not null, Locations.IsDefault: false })
                 {
                     foreach (var l in capture.Locations)
                     {
diff --git a/src/RoslynAnalyzers/PerformanceSensitiveAnalyzers/CSharp/Analyzers/TypeConversionAllocationAnalyzer.cs b/src/RoslynAnalyzers/PerformanceSensitiveAnalyzers/CSharp/Analyzers/TypeConversionAllocationAnalyzer.cs
@@ -179,7 +179,7 @@ private static void ArgumentSyntaxCheck(ArgumentSyntax argument, SemanticModel s
         private static void BinaryExpressionCheck(BinaryExpressionSyntax binaryExpression, SemanticModel semanticModel, bool isAssignmentToReadonly, Action<Diagnostic> reportDiagnostic, CancellationToken cancellationToken)
         {
             // as expression
-            if (binaryExpression.IsKind(SyntaxKind.AsExpression) && binaryExpression.Left != null && binaryExpression.Right != null)
+            if (binaryExpression.IsKind(SyntaxKind.AsExpression) && binaryExpression is { Left: not null, Right: not null })
             {
                 var leftT = semanticModel.GetTypeInfo(binaryExpression.Left, cancellationToken);
                 var rightT = semanticModel.GetTypeInfo(binaryExpression.Right, cancellationToken);
diff --git a/src/RoslynAnalyzers/Utilities/Compiler/DoNotCatchGeneralUnlessRethrown.cs b/src/RoslynAnalyzers/Utilities/Compiler/DoNotCatchGeneralUnlessRethrown.cs
@@ -166,7 +166,7 @@ private bool IsDisallowedCatch(ICatchClauseOperation operation)
 
             private static bool MightBeFilteringBasedOnTheCaughtException(ICatchClauseOperation operation)
             {
-                return operation.ExceptionDeclarationOrExpression != null && operation.Filter != null;
+                return operation is { ExceptionDeclarationOrExpression: not null, Filter: not null };
             }
         }
     }
diff --git a/src/RoslynAnalyzers/Utilities/Compiler/Extensions/IMethodSymbolExtensions.cs b/src/RoslynAnalyzers/Utilities/Compiler/Extensions/IMethodSymbolExtensions.cs
@@ -162,8 +162,7 @@ public static bool IsAsyncDisposeImplementation([NotNullWhen(returnValue: true)]
         /// </summary>
         private static bool HasDisposeMethodSignature(this IMethodSymbol method)
         {
-            return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary &&
-                method.ReturnsVoid && method.Parameters.IsEmpty;
+            return method is { Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters.IsEmpty: true };
         }
 
         /// <summary>
@@ -181,25 +180,18 @@ public static bool HasDisposeSignatureByConvention(this IMethodSymbol method)
         /// </summary>
         public static bool HasDisposeBoolMethodSignature(this IMethodSymbol method)
         {
-            if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary &&
-                method.ReturnsVoid && method.Parameters.Length == 1)
+            return method is
             {
-                IParameterSymbol parameter = method.Parameters[0];
-                return parameter.Type != null &&
-                    parameter.Type.SpecialType == SpecialType.System_Boolean &&
-                    parameter.RefKind == RefKind.None;
-            }
-
-            return false;
+                Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
+            };
         }
 
         /// <summary>
         /// Checks if the given method has the signature "void Close()".
         /// </summary>
         private static bool HasDisposeCloseMethodSignature(this IMethodSymbol method)
         {
-            return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary &&
-                method.ReturnsVoid && method.Parameters.IsEmpty;
+            return method is { Name: "Close", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters.IsEmpty: true };
         }
 
         /// <summary>
diff --git a/src/RoslynAnalyzers/Utilities/Compiler/Extensions/IOperationExtensions.cs b/src/RoslynAnalyzers/Utilities/Compiler/Extensions/IOperationExtensions.cs
@@ -119,7 +119,7 @@ public static ImmutableArray<IOperation> GetTopmostExplicitDescendants(this IOpe
         /// </summary>
         public static bool IsOperationNoneRoot(this IOperation operation)
         {
-            return operation.Kind == OperationKind.None && operation.Parent == null;
+            return operation is { Kind: OperationKind.None, Parent: null };
         }
 
         /// <summary>
diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs
@@ -655,7 +655,7 @@ private static SyntaxNode WithBodies(SyntaxNode declaration)
             case SyntaxKind.ConversionOperatorDeclaration:
             case SyntaxKind.OperatorDeclaration:
                 var method = (BaseMethodDeclarationSyntax)declaration;
-                return (method.Body == null && method.ExpressionBody == null) ? method.WithSemicolonToken(default).WithBody(CreateBlock()) : method;
+                return method is { Body: null, ExpressionBody: null } ? method.WithSemicolonToken(default).WithBody(CreateBlock()) : method;
 
             case SyntaxKind.PropertyDeclaration:
                 var prop = (PropertyDeclarationSyntax)declaration;
@@ -677,16 +677,9 @@ private static AccessorListSyntax WithBodies(AccessorListSyntax accessorList)
         => accessorList.WithAccessors([.. accessorList.Accessors.Select(WithBody)]);
 
     private static AccessorDeclarationSyntax WithBody(AccessorDeclarationSyntax accessor)
-    {
-        if (accessor.Body == null && accessor.ExpressionBody == null)
-        {
-            return accessor.WithSemicolonToken(default).WithBody(CreateBlock(null));
-        }
-        else
-        {
-            return accessor;
-        }
-    }
+        => accessor is { Body: null, ExpressionBody: null }
+            ? accessor.WithSemicolonToken(default).WithBody(CreateBlock(null))
+            : accessor;
 
     private static AccessorListSyntax? WithoutBodies(AccessorListSyntax? accessorList)
         => accessorList?.WithAccessors([.. accessorList.Accessors.Select(WithoutBody)]);
diff --git a/src/Workspaces/CSharp/Portable/Simplification/Simplifiers/AbstractCSharpSimplifier.cs b/src/Workspaces/CSharp/Portable/Simplification/Simplifiers/AbstractCSharpSimplifier.cs
@@ -138,7 +138,7 @@ protected static bool TryReplaceExpressionWithAlias(
 
         // an alias can only replace a type or namespace
         if (symbol == null ||
-            (symbol.Kind != SymbolKind.Namespace && symbol.Kind != SymbolKind.NamedType))
+            symbol is { Kind: not SymbolKind.Namespace and not SymbolKind.NamedType })
         {
             return false;
         }
diff --git a/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs b/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs
@@ -63,7 +63,7 @@ private static ImmutableArray<string> GetStrongNameKeyPaths(ProjectInfo.ProjectA
         // filePath will point to actual file on disk, but in memory solultion, or
         // one from AdhocWorkspace and etc, FilePath/OutputFilePath can be a random string.
         // Make sure we return only if given filePath is in right form.
-        if (info.FilePath == null && info.OutputFilePath == null)
+        if (info is { FilePath: null, OutputFilePath: null })
         {
             // return empty since that is what IDE does for this case
             // see AbstractProject.GetStrongNameKeyPaths
diff --git a/src/Workspaces/Core/Portable/Utilities/Documentation/XmlDocumentationProvider.cs b/src/Workspaces/Core/Portable/Utilities/Documentation/XmlDocumentationProvider.cs
@@ -68,7 +68,7 @@ protected override string GetDocumentationForSymbol(string documentationMemberID
                         var comments = new Dictionary<string, string>();
                         while (xmlReader.Read())
                         {
-                            if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.Name == "member")
+                            if (xmlReader is { NodeType: XmlNodeType.Element, Name: "member" })
                             {
                                 var name = xmlReader.GetAttribute("name");
                                 if (name != null)
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Formatting/TriviaEngine/AbstractTriviaFormatter.cs
@@ -619,7 +619,7 @@ private int GetIndentation()
     /// one new line at the end of the trivia
     /// </summary>
     private static int GetTrailingLinesAtEndOfTrivia1(LineColumn lineColumnAfterTrivia1)
-        => (lineColumnAfterTrivia1.Column == 0 && lineColumnAfterTrivia1.Line > 0) ? 1 : 0;
+        => lineColumnAfterTrivia1 is { Column: 0, Line: > 0 } ? 1 : 0;
 
     private void AddExtraLines(int linesBetweenTokens, ArrayBuilder<SyntaxTrivia> changes)
     {
@@ -765,7 +765,7 @@ private void AddWhitespaceTrivia(
         TextSpan notUsed,
         ArrayBuilder<SyntaxTrivia> changes)
     {
-        if (delta.Lines == 0 && delta.Spaces == 0)
+        if (delta is { Lines: 0, Spaces: 0 })
         {
             // remove trivia
             return;
@@ -868,8 +868,8 @@ private LineColumnDelta GetLineColumnOfWhitespace(
             // if there was already new lines, ignore elastic
             var lineColumnAfterPreviousTrivia = GetLineColumn(lineColumn, previousTrivia);
 
-            var newLineFromPreviousOperation = (whitespaceBetween.Lines > 0) ||
-                                               (lineColumnAfterPreviousTrivia.Line > 0 && lineColumnAfterPreviousTrivia.Column == 0);
+            var newLineFromPreviousOperation = whitespaceBetween.Lines > 0 ||
+                                               lineColumnAfterPreviousTrivia is { Line: > 0, Column: 0 };
             if (newLineFromPreviousOperation && whitespaceBetween.WhitespaceOnly)
             {
                 return LineColumnDelta.Default;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFactsExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SemanticFacts/ISemanticFactsExtensions.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Extensions/Symbols/ISymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Extensions/Symbols/ISymbolExtensions.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CodeGeneration/AttributeGenerator.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CodeGeneration/AttributeGenerator.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CodeGeneration/NamedTypeGenerator.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CodeGeneration/NamedTypeGenerator.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpTypeInferenceService.TypeInferrer.cs

Original file line number	Diff line number	Diff line change
`@@ -481,7 +481,7 @@ private async Task<Solution> FixAsync(`
`481`	`481`	`var isNullLiteral = syntaxFacts.IsNullLiteralExpression(expressionOfArgument);`
`482`	`482`	`var isDefaultLiteral = syntaxFacts.IsDefaultLiteralExpression(expressionOfArgument);`
`483`	`483`
`484`		`- if (argumentTypeInfo.Type == null && argumentTypeInfo.ConvertedType == null)`
	`484`	`+ if (argumentTypeInfo is { Type: null, ConvertedType: null })`
`485`	`485`	`{`
`486`	`486`	`// Didn't know the type of the argument. We shouldn't assume it doesn't`
`487`	`487`	`// match a parameter. However, if the user wrote 'null' and it didn't`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ private static (SyntaxNode newRoot, int nextCaretPosition) AddBraceToIfStatement`
`243`	`243`	`// $$`
`244`	`244`	`// }`
`245`	`245`	`// Print();`
`246`		`- if (ifStatementNode.Else == null && ifStatementNode.Parent is BlockSyntax)`
	`246`	`+ if (ifStatementNode is { Else: null, Parent: BlockSyntax })`
`247`	`247`	`{`
`248`	`248`	`return ReplaceStatementOwnerAndInsertStatement(`
`249`	`249`	`services,`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ private bool ShouldTriggerCompletion(`
`158`	`158`	`//The user may be trying to invoke snippets through question-tab.`
`159`	`159`	`// We may provide a completion after that.`
`160`	`160`	`// Otherwise, tab should not be a completion trigger.`
`161`		`- if (trigger.Reason == AsyncCompletionData.CompletionTriggerReason.Insertion && trigger.Character == '\t')`
	`161`	`+ if (trigger is { Reason: AsyncCompletionData.CompletionTriggerReason.Insertion, Character: '\t' })`
`162`	`162`	`{`
`163`	`163`	`return TryInvokeSnippetCompletion(triggerLocation.Snapshot.TextBuffer, triggerLocation.Position, sourceText, document.Project.Services, completionService.GetRules(options));`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,8 +111,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,`
`111`	`111`	`addEqualsAndQuotes: !nextToken.IsKind(SyntaxKind.EqualsToken) \|\| nextToken.HasLeadingTrivia);`
`112`	`112`	`}`
`113`	`113`
`114`		`- var wasTriggeredAfterSpace = trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character == ' ';`
`115`		`- if (wasTriggeredAfterSpace)`
	`114`	`+ if (trigger is { Kind: CompletionTriggerKind.Insertion, Character: ' ' })`
`116`	`115`	`{`
`117`	`116`	`// Nothing below this point should triggered by a space character`
`118`	`117`	`// (only attribute names should be triggered by <SPACE>)`
`@@ -124,7 +123,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,`
`124`	`123`	`return GetAttributeValueItems(declaredSymbol, elementName, attributeName);`
`125`	`124`	`}`
`126`	`125`
`127`		`- if (trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character != '<')`
	`126`	`+ if (trigger is { Kind: CompletionTriggerKind.Insertion, Character: not '<' })`
`128`	`127`	`{`
`129`	`128`	`// With the use of IsTriggerAfterSpaceOrStartOfWordCharacter, the code below is much`
`130`	`129`	`// too aggressive at suggesting tags, so exit early before degrading the experience`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ public static bool HasBackingField(PropertyDeclarationSyntax property)`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`return property.ExpressionBody == null`
`200`		`- && property.AccessorList!.Accessors.Any(e => e.Body == null && e.ExpressionBody == null);`
	`200`	`+ && property.AccessorList!.Accessors.Any(e => e is { Body: null, ExpressionBody: null });`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ private sealed class AttributeArgumentAnalyzer :`
`81`	`81`	`BaseAnalyzer<AttributeArgumentSyntax, AttributeArgumentListSyntax>`
`82`	`82`	`{`
`83`	`83`	`protected override bool IsPositionalArgument(AttributeArgumentSyntax argument)`
`84`		`- => argument.NameColon == null && argument.NameEquals == null;`
	`84`	`+ => argument is { NameColon: null, NameEquals: null };`
`85`	`85`
`86`	`86`	`protected override SeparatedSyntaxList<AttributeArgumentSyntax> GetArguments(AttributeArgumentListSyntax argumentList)`
`87`	`87`	`=> argumentList.Arguments;`
Original file line number	Diff line number	Diff line change
`@@ -983,7 +983,7 @@ private static void ResolveSymbols(`
`983`	`983`	`newResolution = edit.Symbol.Resolve(newCompilation, cancellationToken: cancellationToken);`
`984`	`984`	`Contract.ThrowIfNull(newResolution.Symbol);`
`985`	`985`	`}`
`986`		`- else if (edit.Kind == SemanticEditKind.Delete && edit.DeletedSymbolContainer is not null)`
	`986`	`+ else if (edit is { Kind: SemanticEditKind.Delete, DeletedSymbolContainer: not null })`
`987`	`987`	`{`
`988`	`988`	`// For deletes, we use NewSymbol to reference the containing type of the deleted member`
`989`	`989`	`newResolution = edit.DeletedSymbolContainer.Value.Resolve(newCompilation, cancellationToken: cancellationToken);`