use patterns

Author: CyrusNajmabadi

src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateConversionService.cs

@@ -28,9 +28,9 @@ internal sealed partial class CSharpGenerateConversionService() :
     protected override bool IsImplicitConversionGeneration(SyntaxNode node)
     {
         return node is ExpressionSyntax &&
-                (node.Parent is AssignmentExpressionSyntax || node.Parent is EqualsValueClauseSyntax) &&
-                !(node is CastExpressionSyntax) &&
-                !(node is MemberAccessExpressionSyntax);
+                node.Parent is AssignmentExpressionSyntax or EqualsValueClauseSyntax &&
+                node is not CastExpressionSyntax &&
+                node is not MemberAccessExpressionSyntax;
     }
 
     protected override bool IsExplicitConversionGeneration(SyntaxNode node)

src/Features/CSharp/Portable/IntroduceUsingStatement/CSharpIntroduceUsingStatementCodeRefactoringProvider.cs

@@ -39,7 +39,7 @@ protected override (SyntaxList<StatementSyntax> tryStatements, SyntaxList<Statem
         => (tryStatement.Block.Statements, tryStatement.Finally?.Block.Statements ?? default);
 
     protected override bool CanRefactorToContainBlockStatements(SyntaxNode parent)
-        => parent is BlockSyntax || parent is SwitchSectionSyntax || parent.IsEmbeddedStatementOwner();
+        => parent is BlockSyntax or SwitchSectionSyntax || parent.IsEmbeddedStatementOwner();
 
     protected override SyntaxList<StatementSyntax> GetSurroundingStatements(StatementSyntax statement)
         => statement.GetRequiredParent() switch

src/Features/CSharp/Portable/SignatureHelp/ElementAccessExpressionSignatureHelpProvider.cs

@@ -295,7 +295,7 @@ internal static bool IsArgumentListToken(ElementAccessExpressionSyntax expressio
         internal static TextSpan GetTextSpan(SyntaxToken openBracket)
         {
             Contract.ThrowIfFalse(openBracket.Parent is BracketedArgumentListSyntax &&
-                (openBracket.Parent.Parent is ElementAccessExpressionSyntax || openBracket.Parent.Parent is ElementBindingExpressionSyntax));
+                openBracket.Parent.Parent is ElementAccessExpressionSyntax or ElementBindingExpressionSyntax);
             return SignatureHelpUtilities.GetSignatureHelpSpan((BracketedArgumentListSyntax)openBracket.Parent);
         }
 

src/Features/Core/Portable/AddImport/SymbolReferenceFinder.cs

@@ -337,7 +337,7 @@ private async Task<ImmutableArray<SymbolReference>> GetReferencesForMatchingFiel
         private bool HasAccessibleStaticFieldOrProperty(INamedTypeSymbol namedType, string fieldOrPropertyName)
         {
             return namedType.GetMembers(fieldOrPropertyName)
-                            .Any(static (m, self) => (m is IFieldSymbol || m is IPropertySymbol) &&
+                            .Any(static (m, self) => (m is IFieldSymbol or IPropertySymbol) &&
                                       m.IsStatic &&
                                       m.IsAccessibleWithin(self._semanticModel.Compilation.Assembly), this);
         }

src/LanguageServer/Protocol/Protocol/Internal/VSInternalLocation.cs

@@ -30,7 +30,7 @@ public object? Text
 
             set
             {
-                if (value is ImageElement || value is ContainerElement || value is ClassifiedTextElement || value is string)
+                if (value is ImageElement or ContainerElement or ClassifiedTextElement or string)
                 {
                     this.textValue = value;
                 }
@@ -41,4 +41,4 @@ public object? Text
             }
         }
     }
-}
+}

src/LanguageServer/Protocol/Protocol/Internal/VSInternalReferenceItem.cs

@@ -68,8 +68,8 @@ public object? DefinitionText
 
             set
             {
-                if (value == null || // Null is accepted since for non-definition references
-                    (value is ImageElement || value is ContainerElement || value is ClassifiedTextElement || value is string))
+                // Null is accepted since for non-definition references
+                if (value is null or ImageElement or ContainerElement or ClassifiedTextElement or string)
                 {
                     this.definitionTextValue = value;
                 }

src/Test/PdbUtilities/EditAndContinue/EditAndContinueTestUtilities.cs

@@ -24,7 +24,7 @@ public static EmitBaseline CreateInitialBaseline(Compilation compilation, Module
             {
                 return module.Module.GetMethodBodyOrThrow(methodHandle)?.LocalSignature ?? default;
             }
-            catch (Exception e) when (e is BadImageFormatException || e is IOException)
+            catch (Exception e) when (e is BadImageFormatException or IOException)
             {
                 throw new InvalidDataException(e.Message, e);
             }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs

@@ -328,13 +328,13 @@ private static void AddEmbeddedStatementsIndentationOperation(List<IndentBlockOp
             return;
         }
 
-        if (node is UsingStatementSyntax usingStatement && usingStatement.Statement != null && !(usingStatement.Statement is BlockSyntax || usingStatement.Statement is UsingStatementSyntax))
+        if (node is UsingStatementSyntax usingStatement && usingStatement.Statement != null && !(usingStatement.Statement is BlockSyntax or UsingStatementSyntax))
         {
             AddEmbeddedStatementsIndentationOperation(list, usingStatement.Statement);
             return;
         }
 
-        if (node is FixedStatementSyntax fixedStatement && fixedStatement.Statement != null && !(fixedStatement.Statement is BlockSyntax || fixedStatement.Statement is FixedStatementSyntax))
+        if (node is FixedStatementSyntax fixedStatement && fixedStatement.Statement != null && !(fixedStatement.Statement is BlockSyntax or FixedStatementSyntax))
         {
             AddEmbeddedStatementsIndentationOperation(list, fixedStatement.Statement);
             return;

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs

@@ -527,7 +527,7 @@ currentToken.Parent is (kind: SyntaxKind.NullableType or SyntaxKind.ClassConstra
         }
 
         // ~ * case
-        if (previousToken.Kind() == SyntaxKind.TildeToken && (previousToken.Parent is PrefixUnaryExpressionSyntax || previousToken.Parent is DestructorDeclarationSyntax))
+        if (previousToken.Kind() == SyntaxKind.TildeToken && (previousToken.Parent is PrefixUnaryExpressionSyntax or DestructorDeclarationSyntax))
         {
             return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
         }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs

@@ -104,7 +104,7 @@ public bool IsOperator(SyntaxToken token)
 
         return
             (SyntaxFacts.IsAnyUnaryExpression(kind) &&
-                (token.Parent is PrefixUnaryExpressionSyntax || token.Parent is PostfixUnaryExpressionSyntax || token.Parent is OperatorDeclarationSyntax)) ||
+                (token.Parent is PrefixUnaryExpressionSyntax or PostfixUnaryExpressionSyntax or OperatorDeclarationSyntax)) ||
             (SyntaxFacts.IsBinaryExpression(kind) && (token.Parent is BinaryExpressionSyntax or OperatorDeclarationSyntax or RelationalPatternSyntax)) ||
             (SyntaxFacts.IsAssignmentExpressionOperatorToken(kind) && token.Parent is AssignmentExpressionSyntax);
     }