Simplify.

Author: JohanLarsson

IDisposableAnalyzers/Analyzers/FieldAndPropertyDeclarationAnalyzer.cs

@@ -37,32 +37,11 @@ context.Node is FieldDeclarationSyntax declaration &&
 
         private static void HandleProperty(SyntaxNodeAnalysisContext context)
         {
-            if (context.IsExcludedFromAnalysis())
-            {
-                return;
-            }
-
-            var property = (IPropertySymbol)context.ContainingSymbol;
-            if (property.IsStatic ||
-                property.IsIndexer)
-            {
-                return;
-            }
-
-            var declaration = (PropertyDeclarationSyntax)context.Node;
-            if (declaration.ExpressionBody != null)
-            {
-                return;
-            }
-
-            if (declaration.TryGetSetter(out var setter) &&
-                setter.Body != null)
-            {
-                // Handle the backing field
-                return;
-            }
-
-            if (Disposable.IsPotentiallyAssignableFrom(property.Type, context.Compilation))
+            if (!context.IsExcludedFromAnalysis() &&
+                context.ContainingSymbol is IPropertySymbol { IsStatic: false, IsIndexer: false } property &&
+                context.Node is PropertyDeclarationSyntax { AccessorList: { Accessors: { } accessors } } declaration &&
+                accessors.First() is { Body: null, ExpressionBody: null } &&
+                Disposable.IsPotentiallyAssignableFrom(property.Type, context.Compilation))
             {
                 HandleFieldOrProperty(context, new FieldOrPropertyAndDeclaration(property, declaration));
             }

IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs

@@ -51,8 +51,7 @@ private static void HandleLambda(SyntaxNodeAnalysisContext context)
         {
             if (!context.IsExcludedFromAnalysis() &&
                 !IsIgnored(context.ContainingSymbol) &&
-                context.Node is LambdaExpressionSyntax lambda &&
-                lambda.Body is ExpressionSyntax expression)
+                context.Node is LambdaExpressionSyntax { Body: ExpressionSyntax expression })
             {
                 HandleReturnValue(context, expression);
             }
@@ -138,9 +137,9 @@ private static bool ShouldAwait(SyntaxNodeAnalysisContext context, ExpressionSyn
             return returnValue switch
             {
                 InvocationExpressionSyntax invocation
-                    => !invocation.IsSymbol(KnownSymbol.Task.FromResult, context.SemanticModel, context.CancellationToken),
+                => !invocation.IsSymbol(KnownSymbol.Task.FromResult, context.SemanticModel, context.CancellationToken),
                 MemberAccessExpressionSyntax { Name: { Identifier: { ValueText: "CompletedTask" } } } memberAccess
-                    => !memberAccess.IsSymbol(KnownSymbol.Task.CompletedTask, context.SemanticModel, context.CancellationToken),
+                => !memberAccess.IsSymbol(KnownSymbol.Task.CompletedTask, context.SemanticModel, context.CancellationToken),
                 _ => true,
             };
         }
@@ -236,9 +235,13 @@ private static bool IsIgnored(ISymbol symbol)
                 return method?.ReturnType;
             }
 
-            return (context.ContainingSymbol as IMethodSymbol)?.ReturnType ??
-                   (context.ContainingSymbol as IFieldSymbol)?.Type ??
-                   (context.ContainingSymbol as IPropertySymbol)?.Type;
+            return context switch
+            {
+                { ContainingSymbol: IFieldSymbol field } => field.Type,
+                { ContainingSymbol: IPropertySymbol property } => property.Type,
+                { ContainingSymbol: IMethodSymbol method } => method.ReturnType,
+                _ => null,
+            };
         }
     }
 }