simplify patterns

Author: JohanLarsson

IDisposableAnalyzers/Analyzers/AssignmentAnalyzer.cs

@@ -56,7 +56,7 @@ private static void Handle(SyntaxNodeAnalysisContext context)
 
         private static bool IsReassignedWithCreated(AssignmentExpressionSyntax assignment, SyntaxNodeAnalysisContext context)
         {
-            if (assignment.Right is IdentifierNameSyntax { Identifier: { ValueText: "value" } } &&
+            if (assignment.Right is IdentifierNameSyntax { Identifier.ValueText: "value" } &&
                 assignment.FirstAncestor<AccessorDeclarationSyntax>() is { } accessor &&
                 accessor.IsKind(SyntaxKind.SetAccessorDeclaration))
             {
@@ -72,9 +72,9 @@ private static bool IsReassignedWithCreated(AssignmentExpressionSyntax assignmen
             {
                 switch (assignedSymbol)
                 {
-                    case IPropertySymbol { ContainingType: { MetadataName: "SerialDisposable`1" }, MetadataName: "Disposable" }:
-                    case IPropertySymbol { ContainingType: { MetadataName: "SerialDisposable" }, MetadataName: "Disposable" }:
-                    case IPropertySymbol { ContainingType: { MetadataName: "SingleAssignmentDisposable" }, MetadataName: "Disposable" }:
+                    case IPropertySymbol { ContainingType.MetadataName: "SerialDisposable`1", MetadataName: "Disposable" }:
+                    case IPropertySymbol { ContainingType.MetadataName: "SerialDisposable", MetadataName: "Disposable" }:
+                    case IPropertySymbol { ContainingType.MetadataName: "SingleAssignmentDisposable", MetadataName: "Disposable" }:
                     case IDiscardSymbol:
                         return false;
                 }
@@ -117,7 +117,7 @@ private static bool IsReassignedWithCreated(AssignmentExpressionSyntax assignmen
                     {
                         using var walker = VariableDeclaratorWalker.Borrow(memberDeclaration);
                         return walker.VariableDeclarators.TrySingle(
-                                    x => x is { Initializer: { Value: { } value } } &&
+                                    x => x is { Initializer.Value: { } value } &&
                                                           context.SemanticModel.TryGetSymbol(value, context.CancellationToken, out var symbol) &&
                                                           SymbolComparer.Equal(symbol, assignedSymbol),
                                     out var match) &&

IDisposableAnalyzers/Analyzers/CreationAnalyzer.cs

@@ -51,7 +51,7 @@ context.ContainingSymbol is { } &&
         {
             return context.Node switch
             {
-                InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } expression, Name: { Identifier: { ValueText: "Schedule" } } } }
+                InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } expression, Name.Identifier.ValueText: "Schedule" } }
                     when context.SemanticModel.TryGetNamedType(expression, context.CancellationToken, out var type) &&
                          type.IsAssignableTo(KnownSymbols.RxIScheduler, context.SemanticModel.Compilation)
                     => null,

IDisposableAnalyzers/Analyzers/DisposeCallAnalyzer.cs

@@ -72,7 +72,7 @@ bool NotLeaveOpen()
                     {
                         return condition switch
                         {
-                            PrefixUnaryExpressionSyntax { OperatorToken: { RawKind: (int)SyntaxKind.ExclamationToken }, Operand: { } operand }
+                            PrefixUnaryExpressionSyntax { OperatorToken.RawKind: (int)SyntaxKind.ExclamationToken, Operand: { } operand }
                                 when Field(operand)?.EndsWith("leaveOpen", StringComparison.OrdinalIgnoreCase) is true &&
                                      ifStatement.Statement.Contains(invocation)
                                 => false,
@@ -180,13 +180,13 @@ declaration is VariableDeclaratorSyntax declarator &&
             bool DeclarationIsAssignment()
             {
                 return localDeclarationStatement!.Parent == expressionStatement!.Parent &&
-                       declarator is { Initializer: { Value: { } value } } &&
+                       declarator is { Initializer.Value: { } value } &&
                        Disposable.IsCreation(value, context.SemanticModel, context.CancellationToken);
             }
 
             bool IsTrivialTryFinally()
             {
-                return expressionStatement!.Parent is BlockSyntax { Statements: { Count: 1 }, Parent: FinallyClauseSyntax { Parent: TryStatementSyntax tryStatement } } &&
+                return expressionStatement!.Parent is BlockSyntax { Statements.Count: 1, Parent: FinallyClauseSyntax { Parent: TryStatementSyntax tryStatement } } &&
                        !tryStatement.Catches.Any();
             }
 

IDisposableAnalyzers/Analyzers/DisposeMethodAnalyzer.cs

@@ -35,7 +35,7 @@ private static void Handle(SyntaxNodeAnalysisContext context)
                 context.ContainingSymbol is IMethodSymbol { IsStatic: false, ReturnsVoid: true, Name: "Dispose" } method &&
                 context.Node is MethodDeclarationSyntax methodDeclaration)
             {
-                if (method is { DeclaredAccessibility: Accessibility.Public, Parameters: { Length: 0 } } &&
+                if (method is { DeclaredAccessibility: Accessibility.Public, Parameters.Length: 0 } &&
                     method.GetAttributes().Length == 0)
                 {
                     if (!method.ExplicitInterfaceImplementations.Any() &&
@@ -100,7 +100,7 @@ private static bool IsInterfaceImplementation(IMethodSymbol method)
             {
                 foreach (var member in @interface.GetMembers())
                 {
-                    if (member is IMethodSymbol { DeclaredAccessibility: Accessibility.Public, ReturnsVoid: true, Name: "Dispose", Parameters: { Length: 0 } })
+                    if (member is IMethodSymbol { DeclaredAccessibility: Accessibility.Public, ReturnsVoid: true, Name: "Dispose", Parameters.Length: 0 })
                     {
                         return true;
                     }

IDisposableAnalyzers/Analyzers/FieldAndPropertyDeclarationAnalyzer.cs

@@ -41,7 +41,7 @@ private static void HandleProperty(SyntaxNodeAnalysisContext context)
         {
             if (!context.IsExcludedFromAnalysis() &&
                 context.ContainingSymbol is IPropertySymbol { IsStatic: false, IsIndexer: false } property &&
-                context.Node is PropertyDeclarationSyntax { AccessorList: { Accessors: { } accessors } } declaration &&
+                context.Node is PropertyDeclarationSyntax { AccessorList.Accessors: { } accessors } declaration &&
                 accessors.FirstOrDefault() is { Body: null, ExpressionBody: null } &&
                 Disposable.IsPotentiallyAssignableFrom(property.Type, context.Compilation))
             {

IDisposableAnalyzers/Analyzers/LocalDeclarationAnalyzer.cs

@@ -45,7 +45,7 @@ private static void Handle(SyntaxNodeAnalysisContext context)
                 {
                     foreach (var declarator in variables)
                     {
-                        if (declarator is { Initializer: { Value: { } value } } &&
+                        if (declarator is { Initializer.Value: { } value } &&
                             Disposable.IsCachedOrInjectedOnly(value, value, context.SemanticModel, context.CancellationToken))
                         {
                             context.ReportDiagnostic(Diagnostic.Create(Descriptors.IDISP007DoNotDisposeInjected, value.GetLocation()));

IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs

@@ -101,7 +101,7 @@ private static void HandleReturnValue(SyntaxNodeAnalysisContext context, Express
                     }
                 }
             }
-            else if (returnValue is InvocationExpressionSyntax { ArgumentList: { Arguments: { } arguments } } invocation &&
+            else if (returnValue is InvocationExpressionSyntax { ArgumentList.Arguments: { } arguments } invocation &&
                      context.ContainingSymbol is { ContainingType: { } containingType })
             {
                 foreach (var argument in arguments)
@@ -153,7 +153,7 @@ private static bool ShouldAwait(SyntaxNodeAnalysisContext context, ExpressionSyn
             {
                 InvocationExpressionSyntax invocation
                 => !invocation.IsSymbol(KnownSymbols.Task.FromResult, context.SemanticModel, context.CancellationToken),
-                MemberAccessExpressionSyntax { Name: { Identifier: { ValueText: "CompletedTask" } } } memberAccess
+                MemberAccessExpressionSyntax { Name.Identifier.ValueText: "CompletedTask" } memberAccess
                 => !memberAccess.IsSymbol(KnownSymbols.Task.CompletedTask, context.SemanticModel, context.CancellationToken),
                 _ => true,
             };

IDisposableAnalyzers/Analyzers/SuppressFinalizeAnalyzer.cs

@@ -22,7 +22,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void Handle(SyntaxNodeAnalysisContext context)
         {
-            if (context.Node is InvocationExpressionSyntax { ArgumentList: { Arguments: { Count: 1 } arguments } } invocation &&
+            if (context.Node is InvocationExpressionSyntax { ArgumentList.Arguments: { Count: 1 } arguments } invocation &&
                 invocation.IsSymbol(KnownSymbols.GC.SuppressFinalize, context.SemanticModel, context.CancellationToken) &&
                 context.SemanticModel.TryGetNamedType(arguments[0].Expression, context.CancellationToken, out var type) &&
                 type.IsSealed &&

IDisposableAnalyzers/Analyzers/UsingStatementAnalyzer.cs

@@ -27,10 +27,10 @@ private static void Handle(SyntaxNodeAnalysisContext context)
             {
                 switch (usingStatement)
                 {
-                    case { Declaration: { Variables: { } variables } }:
+                    case { Declaration.Variables: { } variables }:
                         foreach (var declarator in variables)
                         {
-                            if (declarator is { Initializer: { Value: { } value } } &&
+                            if (declarator is { Initializer.Value: { } value } &&
                                 Disposable.IsCachedOrInjectedOnly(value, value, context.SemanticModel, context.CancellationToken))
                             {
                                 context.ReportDiagnostic(Diagnostic.Create(Descriptors.IDISP007DoNotDisposeInjected, value.GetLocation()));

IDisposableAnalyzers/CodeFixes/AddBaseCallFix.cs

@@ -27,7 +27,7 @@ protected override async Task RegisterCodeFixesAsync(DocumentEditorCodeFixContex
             {
                 if (syntaxRoot?.FindNode(diagnostic.Location.SourceSpan) is MethodDeclarationSyntax { Body: { } body } disposeMethod)
                 {
-                    if (disposeMethod is { ParameterList: { Parameters: { Count: 1 } parameters } } &&
+                    if (disposeMethod is { ParameterList.Parameters: { Count: 1 } parameters } &&
                         parameters.TrySingle(out var parameter))
                     {
                         context.RegisterCodeFix(
@@ -47,7 +47,7 @@ protected override async Task RegisterCodeFixesAsync(DocumentEditorCodeFixContex
                             "base.Dispose()",
                             diagnostic);
                     }
-                    else if (disposeMethod is { ParameterList: { Parameters: { Count: 0 } } })
+                    else if (disposeMethod is { ParameterList.Parameters.Count: 0 })
                     {
                         context.RegisterCodeFix(
                             "base.Dispose()",