fix warnings

JohanLarsson · JohanLarsson · commit 97db4201eaf6 · 2023-04-06T09:11:58.000+02:00
diff --git a/WpfAnalyzers/Analyzers/AttributeAnalyzer.cs b/WpfAnalyzers/Analyzers/AttributeAnalyzer.cs
@@ -42,8 +42,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.ContainingSymbol is { } &&
-            context.Node is AttributeSyntax attribute)
+            context is { ContainingSymbol: { }, Node: AttributeSyntax attribute })
         {
             if (context.SemanticModel.TryGetNamedType(attribute, KnownSymbols.DependsOnAttribute, context.CancellationToken, out _) &&
                 TryFindStringArgument(context, attribute, 0, "name", out var argument, out var expression, out var text))
diff --git a/WpfAnalyzers/Analyzers/CallbackAnalyzer.cs b/WpfAnalyzers/Analyzers/CallbackAnalyzer.cs
@@ -34,8 +34,7 @@ public override void Initialize(AnalysisContext context)
     private static void HandleMethod(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.Node is MethodDeclarationSyntax methodDeclaration &&
-            context.ContainingSymbol is IMethodSymbol { ContainingType: { } containingType } method)
+            context is { Node: MethodDeclarationSyntax methodDeclaration, ContainingSymbol: IMethodSymbol { ContainingType: { } containingType } method })
         {
             if (method.IsStatic)
             {
@@ -272,8 +271,7 @@ private static void HandleCasts(SyntaxNodeAnalysisContext context, SyntaxNode me
             var parent = identifierName.Parent;
             if (parameter.Type == KnownSymbols.DependencyPropertyChangedEventArgs &&
                 parent is MemberAccessExpressionSyntax { Name: IdentifierNameSyntax { Identifier: { } identifier } } memberAccess &&
-                (identifier.ValueText == "NewValue" ||
-                 identifier.ValueText == "OldValue"))
+                identifier.ValueText is "NewValue" or "OldValue")
             {
                 parent = memberAccess.Parent;
             }
diff --git a/WpfAnalyzers/Analyzers/ClrMethodDeclarationAnalyzer.cs b/WpfAnalyzers/Analyzers/ClrMethodDeclarationAnalyzer.cs
@@ -32,8 +32,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.Node is MethodDeclarationSyntax methodDeclaration &&
-            context.ContainingSymbol is IMethodSymbol { IsStatic: true } method &&
+            context is { Node: MethodDeclarationSyntax methodDeclaration, ContainingSymbol: IMethodSymbol { IsStatic: true } method } &&
             method.Parameters.TryElementAt(0, out var element) &&
             element.Type.IsAssignableTo(KnownSymbols.DependencyObject, context.SemanticModel.Compilation))
         {
diff --git a/WpfAnalyzers/Analyzers/ClrPropertyDeclarationAnalyzer.cs b/WpfAnalyzers/Analyzers/ClrPropertyDeclarationAnalyzer.cs
@@ -29,8 +29,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.ContainingSymbol is IPropertySymbol { IsStatic: false } property &&
-            context.Node is PropertyDeclarationSyntax propertyDeclaration &&
+            context is { ContainingSymbol: IPropertySymbol { IsStatic: false } property, Node: PropertyDeclarationSyntax propertyDeclaration } &&
             propertyDeclaration.Getter() is { } getter &&
             propertyDeclaration.Setter() is { } setter)
         {
diff --git a/WpfAnalyzers/Analyzers/ComponentResourceKeyAnalyzer.cs b/WpfAnalyzers/Analyzers/ComponentResourceKeyAnalyzer.cs
@@ -26,8 +26,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.Node is ObjectCreationExpressionSyntax { ArgumentList: { } argumentList } objectCreation &&
-            context.ContainingSymbol is { ContainingType: { } containingType } &&
+            context is { Node: ObjectCreationExpressionSyntax { ArgumentList: { } argumentList } objectCreation, ContainingSymbol.ContainingType: { } containingType } &&
             objectCreation.Type == KnownSymbols.ComponentResourceKey &&
             context.SemanticModel.TryGetSymbol(objectCreation, KnownSymbols.ComponentResourceKey, context.CancellationToken, out var constructor) &&
             FieldOrProperty.TryCreate(context.ContainingSymbol, out var fieldOrProperty))
diff --git a/WpfAnalyzers/Analyzers/DependencyPropertyBackingFieldOrPropertyAnalyzer.cs b/WpfAnalyzers/Analyzers/DependencyPropertyBackingFieldOrPropertyAnalyzer.cs
@@ -31,8 +31,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.ContainingSymbol is { } &&
-            context.Node is MemberDeclarationSyntax memberDeclaration)
+            context is { ContainingSymbol: { }, Node: MemberDeclarationSyntax memberDeclaration })
         {
             if (BackingFieldOrProperty.Match(context.ContainingSymbol) is { } backing)
             {
diff --git a/WpfAnalyzers/Analyzers/GetTemplateChildAnalyzer.cs b/WpfAnalyzers/Analyzers/GetTemplateChildAnalyzer.cs
@@ -102,8 +102,7 @@ argument.Expression is { } expression &&
 
         bool IsMatch(KeyValuePair<string, TypedConstant> a)
         {
-            return a.Key == "Name" &&
-                   a.Value.Value is string candidate &&
+            return a is { Key: "Name", Value.Value: string candidate } &&
                    candidate == part;
         }
     }
@@ -135,9 +134,7 @@ private static bool TryGetCastType(InvocationExpressionSyntax invocation, [NotNu
                 cast = castExpression;
                 type = castExpression.Type;
                 return true;
-            case IsPatternExpressionSyntax { Pattern: DeclarationPatternSyntax declarationPattern } isPattern
-                when
-                !declarationPattern.Type.IsVar:
+            case IsPatternExpressionSyntax { Pattern: DeclarationPatternSyntax { Type.IsVar: false } declarationPattern } isPattern:
                 {
                     cast = isPattern;
                     type = declarationPattern.Type;
diff --git a/WpfAnalyzers/Analyzers/OverrideMetadataAnalyzer.cs b/WpfAnalyzers/Analyzers/OverrideMetadataAnalyzer.cs
@@ -26,8 +26,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.Node is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } expression } } invocation &&
-            context.ContainingSymbol is { } &&
+            context is { Node: InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } expression } } invocation, ContainingSymbol: not null } &&
             DependencyProperty.OverrideMetadata.Match(invocation, context.SemanticModel, context.CancellationToken) is { MetadataArgument: { } metadataArg } &&
             context.SemanticModel.TryGetSymbol(expression, context.CancellationToken, out var candidate) &&
             BackingFieldOrProperty.Match(candidate) is { } backing)
diff --git a/WpfAnalyzers/Analyzers/RoutedCommandCreationAnalyzer.cs b/WpfAnalyzers/Analyzers/RoutedCommandCreationAnalyzer.cs
@@ -31,8 +31,7 @@ public override void Initialize(AnalysisContext context)
 
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
-        if (context.Node is ObjectCreationExpressionSyntax { ArgumentList: { } argumentList } objectCreation &&
-            context.ContainingSymbol is { } containingSymbol &&
+        if (context is { Node: ObjectCreationExpressionSyntax { ArgumentList: { } argumentList } objectCreation, ContainingSymbol: { } containingSymbol } &&
             (objectCreation.Type == KnownSymbols.RoutedCommand || objectCreation.Type == KnownSymbols.RoutedUICommand) &&
             context.SemanticModel.TryGetSymbol(objectCreation, context.CancellationToken, out var ctor))
         {
diff --git a/WpfAnalyzers/Analyzers/RoutedEventEventDeclarationAnalyzer.cs b/WpfAnalyzers/Analyzers/RoutedEventEventDeclarationAnalyzer.cs
@@ -101,7 +101,7 @@ private class EventDeclarationWalker : PooledWalker<EventDeclarationWalker>
         public override void VisitInvocationExpression(InvocationExpressionSyntax node)
         {
             if (node.TryGetMethodName(out var name) &&
-                (name == "AddHandler" || name == "RemoveHandler") &&
+                name is "AddHandler" or "RemoveHandler" &&
                 node.FirstAncestor<AccessorDeclarationSyntax>() is { } accessor)
             {
                 if (accessor.IsKind(SyntaxKind.AddAccessorDeclaration))
diff --git a/WpfAnalyzers/CodeFixes/RenameMemberFix.cs b/WpfAnalyzers/CodeFixes/RenameMemberFix.cs
@@ -47,7 +47,7 @@ semanticModel is { } &&
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         $"Rename to: '{newName}'.",
-                        cancellationToken => Renamer.RenameSymbolAsync(context.Document.Project.Solution, symbol, newName, context.Document.Project.Solution.Workspace.Options, cancellationToken),
+                        cancellationToken => Renamer.RenameSymbolAsync(context.Document.Project.Solution, symbol, default, newName, cancellationToken),
                         this.GetType().FullName),
                     diagnostic);
             }
diff --git a/WpfAnalyzers/Helpers/BackingFieldOrProperty.cs b/WpfAnalyzers/Helpers/BackingFieldOrProperty.cs
@@ -172,10 +172,9 @@ IPropertySymbol property
 
     internal BackingFieldOrProperty? FindAddOwnerSource(SemanticModel semanticModel, CancellationToken cancellationToken)
     {
-        if (this.Value(cancellationToken) is { } value &&
-            value is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } addOwner } } invocation &&
+        if (this.Value(cancellationToken) is { } and InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Expression: { } addOwner } } invocation &&
             semanticModel.TryGetSymbol(invocation, KnownSymbols.DependencyProperty.AddOwner, cancellationToken, out _) &&
-            semanticModel.TryGetSymbol(addOwner, cancellationToken, out var addOwnerSymbol))
+            semanticModel.TryGetSymbol(addOwner,   cancellationToken,                        out var addOwnerSymbol))
         {
             return Match(addOwnerSymbol);
         }
diff --git a/WpfAnalyzers/Helpers/EventManager.cs b/WpfAnalyzers/Helpers/EventManager.cs
@@ -116,8 +116,7 @@ internal AddHandler(InvocationExpressionSyntax invocation, IMethodSymbol target)
 
         internal static AddHandler? Match(InvocationExpressionSyntax invocation, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
-            if (invocation is { ArgumentList.Arguments: { } arguments } &&
-                arguments.Count is 2 or 3 &&
+            if (invocation is { ArgumentList.Arguments.Count: 2 or 3 } &&
                 invocation.TryGetMethodName(out var name) &&
                 name == "AddHandler" &&
                 semanticModel.TryGetSymbol(invocation, cancellationToken, out var method) &&
diff --git a/WpfAnalyzers/Helpers/MarkupExtension.cs b/WpfAnalyzers/Helpers/MarkupExtension.cs
@@ -15,10 +15,7 @@ internal static bool TryGetReturnType(ClassDeclarationSyntax classDeclaration, S
     {
         returnType = null;
         if (classDeclaration.TryFindMethod("ProvideValue", out var convertMethod) &&
-            convertMethod.ReturnType is PredefinedTypeSyntax predefinedType &&
-            predefinedType.Keyword.ValueText == "object" &&
-            convertMethod.ParameterList is { } &&
-            convertMethod.ParameterList.Parameters.Count == 1)
+            convertMethod is { ReturnType: PredefinedTypeSyntax { Keyword.ValueText: "object" }, ParameterList.Parameters.Count: 1 })
         {
             using var walker = ReturnValueWalker.Borrow(convertMethod);
             using var returnTypes = PooledSet<ITypeSymbol>.Borrow();
diff --git a/WpfAnalyzers/Helpers/ValueConverter.cs b/WpfAnalyzers/Helpers/ValueConverter.cs
@@ -18,18 +18,13 @@ internal static bool TryGetDefaultFieldsOrProperties(ITypeSymbol type, Compilati
         foreach (var member in type.GetMembers())
         {
             if (member.IsStatic &&
-                (member.DeclaredAccessibility == Accessibility.Public ||
-                 member.DeclaredAccessibility == Accessibility.Internal))
+                member.DeclaredAccessibility is Accessibility.Public or Accessibility.Internal)
             {
                 if (FieldOrProperty.TryCreate(member, out var fieldOrProperty) &&
                     (fieldOrProperty.Type.IsAssignableTo(KnownSymbols.IValueConverter,      compilation) ||
                      fieldOrProperty.Type.IsAssignableTo(KnownSymbols.IMultiValueConverter, compilation)))
                 {
-                    if (temp is null)
-                    {
-                        temp = new List<FieldOrProperty>();
-                    }
-
+                    temp ??= new List<FieldOrProperty>();
                     temp.Add(fieldOrProperty);
                 }
             }
diff --git a/WpfAnalyzers/Helpers/Walkers/ConversionWalker.cs b/WpfAnalyzers/Helpers/Walkers/ConversionWalker.cs
@@ -107,11 +107,7 @@ internal static bool TryGetCommonBase(SyntaxNode node, IParameterSymbol symbol,
         }
 
         // If we couldn't "guess" a source type we take parameters type
-        if (sourceType is null)
-        {
-            sourceType = symbol.Type;
-        }
-
+        sourceType ??= symbol.Type;
         return true;
 
         bool IsFor(ExpressionSyntax e, ISymbol s, SemanticModel sm, CancellationToken ct)
diff --git a/WpfAnalyzers/WPF0080MarkupExtensionDoesNotHaveAttribute.cs b/WpfAnalyzers/WPF0080MarkupExtensionDoesNotHaveAttribute.cs
@@ -23,8 +23,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.ContainingSymbol is INamedTypeSymbol { IsGenericType: false } type &&
-            context.Node is ClassDeclarationSyntax classDeclaration &&
+            context is { ContainingSymbol: INamedTypeSymbol { IsGenericType: false } type, Node: ClassDeclarationSyntax classDeclaration } &&
             type.IsAssignableTo(KnownSymbols.MarkupExtension, context.SemanticModel.Compilation) &&
             type.TryFindFirstMethod("ProvideValue", x => x.Parameters.TrySingle(out var parameter) && parameter.Type == KnownSymbols.IServiceProvider, out _) &&
             !Attribute.TryFind(classDeclaration, KnownSymbols.MarkupExtensionReturnTypeAttribute, context.SemanticModel, context.CancellationToken, out _))
diff --git a/WpfAnalyzers/WPF0083UseConstructorArgumentAttribute.cs b/WpfAnalyzers/WPF0083UseConstructorArgumentAttribute.cs
@@ -25,8 +25,7 @@ public override void Initialize(AnalysisContext context)
     private static void Handle(SyntaxNodeAnalysisContext context)
     {
         if (!context.IsExcludedFromAnalysis() &&
-            context.Node is PropertyDeclarationSyntax propertyDeclaration &&
-            context.ContainingSymbol is IPropertySymbol property &&
+            context is { Node: PropertyDeclarationSyntax propertyDeclaration, ContainingSymbol: IPropertySymbol property } &&
             property.ContainingType.IsAssignableTo(KnownSymbols.MarkupExtension, context.SemanticModel.Compilation) &&
             !Attribute.TryFind(propertyDeclaration, KnownSymbols.ConstructorArgumentAttribute, context.SemanticModel, context.CancellationToken, out _) &&
             ConstructorArgument.TryGetParameterName(property, context.SemanticModel, context.CancellationToken, out var parameterName))

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,7 @@ public override void Initialize(AnalysisContext context)`
`42`	`42`	`private static void Handle(SyntaxNodeAnalysisContext context)`
`43`	`43`	`{`
`44`	`44`	`if (!context.IsExcludedFromAnalysis() &&`
`45`		`- context.ContainingSymbol is { } &&`
`46`		`- context.Node is AttributeSyntax attribute)`
	`45`	`+ context is { ContainingSymbol: { }, Node: AttributeSyntax attribute })`
`47`	`46`	`{`
`48`	`47`	`if (context.SemanticModel.TryGetNamedType(attribute, KnownSymbols.DependsOnAttribute, context.CancellationToken, out _) &&`
`49`	`48`	`TryFindStringArgument(context, attribute, 0, "name", out var argument, out var expression, out var text))`
Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,7 @@ public override void Initialize(AnalysisContext context)`
`34`	`34`	`private static void HandleMethod(SyntaxNodeAnalysisContext context)`
`35`	`35`	`{`
`36`	`36`	`if (!context.IsExcludedFromAnalysis() &&`
`37`		`- context.Node is MethodDeclarationSyntax methodDeclaration &&`
`38`		`- context.ContainingSymbol is IMethodSymbol { ContainingType: { } containingType } method)`
	`37`	`+ context is { Node: MethodDeclarationSyntax methodDeclaration, ContainingSymbol: IMethodSymbol { ContainingType: { } containingType } method })`
`39`	`38`	`{`
`40`	`39`	`if (method.IsStatic)`
`41`	`40`	`{`
`@@ -272,8 +271,7 @@ private static void HandleCasts(SyntaxNodeAnalysisContext context, SyntaxNode me`
`272`	`271`	`var parent = identifierName.Parent;`
`273`	`272`	`if (parameter.Type == KnownSymbols.DependencyPropertyChangedEventArgs &&`
`274`	`273`	`parent is MemberAccessExpressionSyntax { Name: IdentifierNameSyntax { Identifier: { } identifier } } memberAccess &&`
`275`		`- (identifier.ValueText == "NewValue" \|\|`
`276`		`- identifier.ValueText == "OldValue"))`
	`274`	`+ identifier.ValueText is "NewValue" or "OldValue")`
`277`	`275`	`{`
`278`	`276`	`parent = memberAccess.Parent;`
`279`	`277`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,7 @@ public override void Initialize(AnalysisContext context)`
`32`	`32`	`private static void Handle(SyntaxNodeAnalysisContext context)`
`33`	`33`	`{`
`34`	`34`	`if (!context.IsExcludedFromAnalysis() &&`
`35`		`- context.Node is MethodDeclarationSyntax methodDeclaration &&`
`36`		`- context.ContainingSymbol is IMethodSymbol { IsStatic: true } method &&`
	`35`	`+ context is { Node: MethodDeclarationSyntax methodDeclaration, ContainingSymbol: IMethodSymbol { IsStatic: true } method } &&`
`37`	`36`	`method.Parameters.TryElementAt(0, out var element) &&`
`38`	`37`	`element.Type.IsAssignableTo(KnownSymbols.DependencyObject, context.SemanticModel.Compilation))`
`39`	`38`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,7 @@ public override void Initialize(AnalysisContext context)`
`29`	`29`	`private static void Handle(SyntaxNodeAnalysisContext context)`
`30`	`30`	`{`
`31`	`31`	`if (!context.IsExcludedFromAnalysis() &&`
`32`		`- context.ContainingSymbol is IPropertySymbol { IsStatic: false } property &&`
`33`		`- context.Node is PropertyDeclarationSyntax propertyDeclaration &&`
	`32`	`+ context is { ContainingSymbol: IPropertySymbol { IsStatic: false } property, Node: PropertyDeclarationSyntax propertyDeclaration } &&`
`34`	`33`	`propertyDeclaration.Getter() is { } getter &&`
`35`	`34`	`propertyDeclaration.Setter() is { } setter)`
`36`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,7 @@ public override void Initialize(AnalysisContext context)`
`31`	`31`	`private static void Handle(SyntaxNodeAnalysisContext context)`
`32`	`32`	`{`
`33`	`33`	`if (!context.IsExcludedFromAnalysis() &&`
`34`		`- context.ContainingSymbol is { } &&`
`35`		`- context.Node is MemberDeclarationSyntax memberDeclaration)`
	`34`	`+ context is { ContainingSymbol: { }, Node: MemberDeclarationSyntax memberDeclaration })`
`36`	`35`	`{`
`37`	`36`	`if (BackingFieldOrProperty.Match(context.ContainingSymbol) is { } backing)`
`38`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -102,8 +102,7 @@ argument.Expression is { } expression &&`
`102`	`102`
`103`	`103`	`bool IsMatch(KeyValuePair<string, TypedConstant> a)`
`104`	`104`	`{`
`105`		`- return a.Key == "Name" &&`
`106`		`- a.Value.Value is string candidate &&`
	`105`	`+ return a is { Key: "Name", Value.Value: string candidate } &&`
`107`	`106`	`candidate == part;`
`108`	`107`	`}`
`109`	`108`	`}`
`@@ -135,9 +134,7 @@ private static bool TryGetCastType(InvocationExpressionSyntax invocation, [NotNu`
`135`	`134`	`cast = castExpression;`
`136`	`135`	`type = castExpression.Type;`
`137`	`136`	`return true;`
`138`		`- case IsPatternExpressionSyntax { Pattern: DeclarationPatternSyntax declarationPattern } isPattern`
`139`		`- when`
`140`		`- !declarationPattern.Type.IsVar:`
	`137`	`+ case IsPatternExpressionSyntax { Pattern: DeclarationPatternSyntax { Type.IsVar: false } declarationPattern } isPattern:`
`141`	`138`	`{`
`142`	`139`	`cast = isPattern;`
`143`	`140`	`type = declarationPattern.Type;`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ private class EventDeclarationWalker : PooledWalker<EventDeclarationWalker>`
`101`	`101`	`public override void VisitInvocationExpression(InvocationExpressionSyntax node)`
`102`	`102`	`{`
`103`	`103`	`if (node.TryGetMethodName(out var name) &&`
`104`		`- (name == "AddHandler" \|\| name == "RemoveHandler") &&`
	`104`	`+ name is "AddHandler" or "RemoveHandler" &&`
`105`	`105`	`node.FirstAncestor<AccessorDeclarationSyntax>() is { } accessor)`
`106`	`106`	`{`
`107`	`107`	`if (accessor.IsKind(SyntaxKind.AddAccessorDeclaration))`