Updated formatting to Resharper v2021.3.3

Bart Koelman · Bart Koelman · commit 98f3f39eb014 · 2022-02-02T15:50:32.000+01:00
diff --git a/src/CSharpGuidelinesAnalyzer.sln.DotSettings b/src/CSharpGuidelinesAnalyzer.sln.DotSettings
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/AnalyzerCategory.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/AnalyzerCategory.cs
@@ -51,7 +51,6 @@ public string GetHelpLinkUri([NotNull] string ruleId)
 
             string ruleNumber = ruleId.Substring(2);
             return $"https://github.com/dennisdoomen/CSharpGuidelines/blob/{CommitHash}/_rules/{ruleNumber}.md";
-
         }
     }
 }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/BaseAnalysisContext.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/BaseAnalysisContext.cs
@@ -12,7 +12,7 @@ namespace CSharpGuidelinesAnalyzer
     /// <typeparam name="TTarget">
     /// The target for analysis. Typically a syntax node, symbol or operation.
     /// </typeparam>
-    internal struct BaseAnalysisContext<TTarget>
+    internal readonly struct BaseAnalysisContext<TTarget>
     {
         [NotNull]
         private readonly Action<Diagnostic> reportDiagnosticCallback;
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/DiagnosticCollector.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/DiagnosticCollector.cs
@@ -42,11 +42,7 @@ public void Add([NotNull] Diagnostic diagnostic)
         {
             Guard.NotNull(diagnostic, nameof(diagnostic));
 
-            if (diagnostics == null)
-            {
-                diagnostics = new List<Diagnostic>();
-            }
-
+            diagnostics ??= new List<Diagnostic>();
             diagnostics.Add(diagnostic);
         }
 
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/ExplicitOperationVisitor.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/ExplicitOperationVisitor.cs
@@ -11,7 +11,7 @@ internal class ExplicitOperationVisitor : OperationVisitor
     {
         public override void Visit([CanBeNull] IOperation operation)
         {
-            if (operation != null && !operation.IsImplicit)
+            if (operation is { IsImplicit: false })
             {
                 operation.Accept(this);
             }
@@ -26,7 +26,7 @@ internal abstract class ExplicitOperationVisitor<TArgument, TResult> : Operation
         [CanBeNull]
         public override TResult Visit([CanBeNull] IOperation operation, [CanBeNull] TArgument argument)
         {
-            if (operation != null && !operation.IsImplicit)
+            if (operation is { IsImplicit: false })
             {
                 return operation.Accept(this, argument);
             }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/ExplicitOperationWalker.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/ExplicitOperationWalker.cs
@@ -11,7 +11,7 @@ internal abstract class ExplicitOperationWalker : OperationWalker
     {
         public override void Visit([CanBeNull] IOperation operation)
         {
-            if (operation != null && !operation.IsImplicit)
+            if (operation is { IsImplicit: false })
             {
                 base.Visit(operation);
             }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/OperationExtensions.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/OperationExtensions.cs
@@ -487,7 +487,7 @@ public override Location VisitTypeOf([NotNull] ITypeOfOperation operation, [CanB
             [NotNull]
             public override Location VisitNameOf([NotNull] INameOfOperation operation, [CanBeNull] object argument)
             {
-                if (operation.Syntax is InvocationExpressionSyntax invocationSyntax && invocationSyntax.Expression is IdentifierNameSyntax expressionSyntax)
+                if (operation.Syntax is InvocationExpressionSyntax { Expression: IdentifierNameSyntax expressionSyntax })
                 {
                     return expressionSyntax.GetLocation();
                 }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/SymbolExtensions.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/SymbolExtensions.cs
@@ -283,7 +283,7 @@ public static bool IsSymbolAccessibleFromRoot([CanBeNull] this ISymbol symbol)
 
         public static bool IsDeconstructor([CanBeNull] this ISymbol symbol)
         {
-            return symbol is IMethodSymbol method && method.Name == "Deconstruct";
+            return symbol is IMethodSymbol { Name: "Deconstruct" };
         }
 
         [NotNull]
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/NullCheckScanner.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/NullCheckScanner.cs
@@ -190,7 +190,7 @@ private NullCheckOperand GetParentNullCheckOperand([NotNull] IOperation operatio
 
             IOperation currentOperation = operation.Parent;
 
-            while (currentOperation is IUnaryOperation unaryOperation && unaryOperation.OperatorKind == UnaryOperatorKind.Not)
+            while (currentOperation is IUnaryOperation { OperatorKind: UnaryOperatorKind.Not })
             {
                 operand = operand.Toggle();
                 currentOperation = currentOperation.Parent;
@@ -319,7 +319,7 @@ private IMethodSymbol ResolveEqualityComparerEquals([NotNull] Compilation compil
             }
         }
 
-        private struct ArgumentsInfo
+        private readonly struct ArgumentsInfo
         {
             [NotNull]
             public IOperation LeftArgument { get; }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/DoNotHideInheritedMemberAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/DoNotHideInheritedMemberAnalyzer.cs
@@ -42,7 +42,7 @@ public override void Initialize([NotNull] AnalysisContext context)
 
         private static void AnalyzeMember(SymbolAnalysisContext context)
         {
-            if (context.Symbol is INamedTypeSymbol typeSymbol && typeSymbol.ContainingType == null)
+            if (context.Symbol is INamedTypeSymbol { ContainingType: null })
             {
                 return;
             }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Framework/AvoidQuerySyntaxForSimpleExpressionAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Framework/AvoidQuerySyntaxForSimpleExpressionAnalyzer.cs
@@ -87,7 +87,7 @@ private static bool ProjectsIntoGroup([NotNull] SelectOrGroupClauseSyntax select
 
         private static bool ProjectsIntoAnonymousType([NotNull] SelectOrGroupClauseSyntax selectOrGroupClause)
         {
-            return selectOrGroupClause is SelectClauseSyntax selectClause && selectClause.Expression is AnonymousObjectCreationExpressionSyntax;
+            return selectOrGroupClause is SelectClauseSyntax { Expression: AnonymousObjectCreationExpressionSyntax _ };
         }
 
         private static int GetComplexityForClauses([NotNull] QueryExpressionSyntax queryExpression)
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Framework/PreferLanguageSyntaxOverCallingImplementationAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Framework/PreferLanguageSyntaxOverCallingImplementationAnalyzer.cs
@@ -76,7 +76,7 @@ private static void AnalyzePropertyReference(OperationAnalysisContext context, [
 
             NullCheckScanResult? scanResult = scanner.ScanPropertyReference(propertyReference);
 
-            if (scanResult != null && scanResult.Value.Method == NullCheckMethod.NullableHasValueMethod)
+            if (scanResult is { Method: NullCheckMethod.NullableHasValueMethod })
             {
                 if (propertyReference.Parent is IBinaryOperation binaryOperator && DoReportForNullableComparison(binaryOperator, scanner))
                 {
@@ -159,15 +159,15 @@ private static IOperation TryGetTargetInNotNullCheck([NotNull] IOperation operat
             var visitor = new NullCheckVisitor(scanner);
             visitor.Visit(targetOperation);
 
-            return visitor.ScanResult != null && visitor.ScanResult.Value.Operand == NullCheckOperand.IsNotNull ? visitor.ScanResult.Value.Target : null;
+            return visitor.ScanResult is { Operand: NullCheckOperand.IsNotNull } ? visitor.ScanResult.Value.Target : null;
         }
 
         [NotNull]
         private static IOperation SkipNotOperators([NotNull] IOperation operation)
         {
             IOperation currentOperation = operation;
 
-            while (currentOperation is IUnaryOperation unaryOperation && unaryOperation.OperatorKind == UnaryOperatorKind.Not)
+            while (currentOperation is IUnaryOperation { OperatorKind: UnaryOperatorKind.Not } unaryOperation)
             {
                 currentOperation = unaryOperation.Operand;
             }
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/AvoidBooleanParameterAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/AvoidBooleanParameterAnalyzer.cs
@@ -75,7 +75,7 @@ private static bool IsDisposablePattern([NotNull] IParameterSymbol parameter)
         {
             if (parameter.Name == "disposing")
             {
-                if (parameter.ContainingSymbol is IMethodSymbol containingMethod && containingMethod.Name == "Dispose")
+                if (parameter.ContainingSymbol is IMethodSymbol { Name: "Dispose" } containingMethod)
                 {
                     if (containingMethod.IsVirtual && containingMethod.DeclaredAccessibility == Accessibility.Protected)
                     {
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/AvoidSignatureWithManyParametersAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/AvoidSignatureWithManyParametersAnalyzer.cs
@@ -310,7 +310,7 @@ public ParameterSettings(int maxParameterCount, int maxConstructorParameterCount
             }
         }
 
-        private struct ParameterCountInfo<TTarget>
+        private readonly struct ParameterCountInfo<TTarget>
         {
             public BaseAnalysisContext<TTarget> Context { get; }
 
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/SwitchStatementShouldHaveDefaultCaseAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/SwitchStatementShouldHaveDefaultCaseAnalyzer.cs
@@ -137,7 +137,7 @@ private static bool IsDefaultOrPatternCase([NotNull] ICaseClauseOperation clause
         [CanBeNull]
         private static bool? IsSwitchExhaustiveForEnumerationTypes([NotNull] IdentifierInfo identifierInfo, [NotNull] SwitchAnalysisContext analysisContext)
         {
-            bool isEnumeration = identifierInfo.Type.BaseType != null && identifierInfo.Type.BaseType.SpecialType == SpecialType.System_Enum;
+            bool isEnumeration = identifierInfo.Type.BaseType is { SpecialType: SpecialType.System_Enum };
 
             bool isNullableEnumeration = identifierInfo.Type.IsNullableEnumeration();
 
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/MiscellaneousDesign/EvaluateQueryBeforeReturnAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/MiscellaneousDesign/EvaluateQueryBeforeReturnAnalyzer.cs
@@ -91,7 +91,7 @@ private static void AnalyzeCodeBlock(OperationBlockAnalysisContext context, [Not
 
         private static bool IsInMethodThatReturnsEnumerable([NotNull] ISymbol owningSymbol, [NotNull] SequenceTypeInfo sequenceTypeInfo)
         {
-            return owningSymbol is IMethodSymbol method && !method.ReturnsVoid && sequenceTypeInfo.IsEnumerable(method.ReturnType);
+            return owningSymbol is IMethodSymbol { ReturnsVoid: false } method && sequenceTypeInfo.IsEnumerable(method.ReturnType);
         }
 
         private static void AnalyzeReturnStatements([NotNull] [ItemNotNull] IList<IReturnOperation> returnStatements, OperationBlockAnalysisContext context)
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Naming/DoNotUseAbbreviationInIdentifierNameAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Naming/DoNotUseAbbreviationInIdentifierNameAnalyzer.cs
@@ -225,7 +225,7 @@ private static ILocalSymbol TryGetTupleElement([NotNull] IOperation elementOpera
                 ? declarationExpression.Expression as ILocalReferenceOperation
                 : elementOperation as ILocalReferenceOperation;
 
-            return localReference != null && localReference.IsDeclaration ? localReference.Local : null;
+            return localReference is { IsDeclaration: true } ? localReference.Local : null;
         }
 
         private static void AnalyzeAnonymousObjectCreation(OperationAnalysisContext context)
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Naming/DoNotUseNumberInIdentifierNameAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Naming/DoNotUseNumberInIdentifierNameAnalyzer.cs
@@ -238,7 +238,7 @@ private static ILocalSymbol TryGetTupleElement([NotNull] IOperation elementOpera
                 ? declarationExpression.Expression as ILocalReferenceOperation
                 : elementOperation as ILocalReferenceOperation;
 
-            return localReference != null && localReference.IsDeclaration ? localReference.Local : null;
+            return localReference is { IsDeclaration: true } ? localReference.Local : null;
         }
 
         private static void AnalyzeAnonymousObjectCreation(OperationAnalysisContext context)
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/OperationHasKeywordAnalyzer.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/OperationHasKeywordAnalyzer.cs
@@ -61,7 +61,7 @@ private static void AnalyzeExplicitOperation(OperationAnalysisContext context)
 
         private static bool IsReportAtAlternateLocation([NotNull] IOperation operation)
         {
-            return operation.Parent?.Parent?.Syntax is MethodDeclarationSyntax methodSyntax && methodSyntax.Identifier.ValueText == "ReportAtAlternateLocation";
+            return operation.Parent?.Parent?.Syntax is MethodDeclarationSyntax { Identifier: { ValueText: "ReportAtAlternateLocation" } };
         }
 
         private static void AnalyzeLocationForOperation(OperationAnalysisContext context, DoWhileLoopLookupKeywordStrategy doWhileStrategy,
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Settings/AnalyzerSettingsReader.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Settings/AnalyzerSettingsReader.cs
@@ -95,7 +95,7 @@ public bool TryGetOptionValue([NotNull] SyntaxTree syntaxTree, [NotNull] string
                         syntaxTree
                     });
 
-                    var parameters = new object[]
+                    object[] parameters =
                     {
                         key,
                         null
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/WordToken.cs b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/WordToken.cs
@@ -3,7 +3,7 @@
 
 namespace CSharpGuidelinesAnalyzer
 {
-    public struct WordToken : IEquatable<WordToken>
+    public readonly struct WordToken : IEquatable<WordToken>
     {
         [NotNull]
         public string Text { get; }

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ public string GetHelpLinkUri([NotNull] string ruleId)`
`51`	`51`
`52`	`52`	`string ruleNumber = ruleId.Substring(2);`
`53`	`53`	`return $"https://github.com/dennisdoomen/CSharpGuidelines/blob/{CommitHash}/_rules/{ruleNumber}.md";`
`54`		`-`
`55`	`54`	`}`
`56`	`55`	`}`
`57`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace CSharpGuidelinesAnalyzer`
`12`	`12`	`/// <typeparam name="TTarget">`
`13`	`13`	`/// The target for analysis. Typically a syntax node, symbol or operation.`
`14`	`14`	`/// </typeparam>`
`15`		`- internal struct BaseAnalysisContext<TTarget>`
	`15`	`+ internal readonly struct BaseAnalysisContext<TTarget>`
`16`	`16`	`{`
`17`	`17`	`[NotNull]`
`18`	`18`	`private readonly Action<Diagnostic> reportDiagnosticCallback;`
Original file line number	Diff line number	Diff line change
`@@ -42,11 +42,7 @@ public void Add([NotNull] Diagnostic diagnostic)`
`42`	`42`	`{`
`43`	`43`	`Guard.NotNull(diagnostic, nameof(diagnostic));`
`44`	`44`
`45`		`- if (diagnostics == null)`
`46`		`- {`
`47`		`- diagnostics = new List<Diagnostic>();`
`48`		`- }`
`49`		`-`
	`45`	`+ diagnostics ??= new List<Diagnostic>();`
`50`	`46`	`diagnostics.Add(diagnostic);`
`51`	`47`	`}`
`52`	`48`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal class ExplicitOperationVisitor : OperationVisitor`
`11`	`11`	`{`
`12`	`12`	`public override void Visit([CanBeNull] IOperation operation)`
`13`	`13`	`{`
`14`		`- if (operation != null && !operation.IsImplicit)`
	`14`	`+ if (operation is { IsImplicit: false })`
`15`	`15`	`{`
`16`	`16`	`operation.Accept(this);`
`17`	`17`	`}`
`@@ -26,7 +26,7 @@ internal abstract class ExplicitOperationVisitor<TArgument, TResult> : Operation`
`26`	`26`	`[CanBeNull]`
`27`	`27`	`public override TResult Visit([CanBeNull] IOperation operation, [CanBeNull] TArgument argument)`
`28`	`28`	`{`
`29`		`- if (operation != null && !operation.IsImplicit)`
	`29`	`+ if (operation is { IsImplicit: false })`
`30`	`30`	`{`
`31`	`31`	`return operation.Accept(this, argument);`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal abstract class ExplicitOperationWalker : OperationWalker`
`11`	`11`	`{`
`12`	`12`	`public override void Visit([CanBeNull] IOperation operation)`
`13`	`13`	`{`
`14`		`- if (operation != null && !operation.IsImplicit)`
	`14`	`+ if (operation is { IsImplicit: false })`
`15`	`15`	`{`
`16`	`16`	`base.Visit(operation);`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -487,7 +487,7 @@ public override Location VisitTypeOf([NotNull] ITypeOfOperation operation, [CanB`
`487`	`487`	`[NotNull]`
`488`	`488`	`public override Location VisitNameOf([NotNull] INameOfOperation operation, [CanBeNull] object argument)`
`489`	`489`	`{`
`490`		`- if (operation.Syntax is InvocationExpressionSyntax invocationSyntax && invocationSyntax.Expression is IdentifierNameSyntax expressionSyntax)`
	`490`	`+ if (operation.Syntax is InvocationExpressionSyntax { Expression: IdentifierNameSyntax expressionSyntax })`
`491`	`491`	`{`
`492`	`492`	`return expressionSyntax.GetLocation();`
`493`	`493`	`}`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@ public static bool IsSymbolAccessibleFromRoot([CanBeNull] this ISymbol symbol)`
`283`	`283`
`284`	`284`	`public static bool IsDeconstructor([CanBeNull] this ISymbol symbol)`
`285`	`285`	`{`
`286`		`- return symbol is IMethodSymbol method && method.Name == "Deconstruct";`
	`286`	`+ return symbol is IMethodSymbol { Name: "Deconstruct" };`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`[NotNull]`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ private NullCheckOperand GetParentNullCheckOperand([NotNull] IOperation operatio`
`190`	`190`
`191`	`191`	`IOperation currentOperation = operation.Parent;`
`192`	`192`
`193`		`- while (currentOperation is IUnaryOperation unaryOperation && unaryOperation.OperatorKind == UnaryOperatorKind.Not)`
	`193`	`+ while (currentOperation is IUnaryOperation { OperatorKind: UnaryOperatorKind.Not })`
`194`	`194`	`{`
`195`	`195`	`operand = operand.Toggle();`
`196`	`196`	`currentOperation = currentOperation.Parent;`
`@@ -319,7 +319,7 @@ private IMethodSymbol ResolveEqualityComparerEquals([NotNull] Compilation compil`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
`322`		`- private struct ArgumentsInfo`
	`322`	`+ private readonly struct ArgumentsInfo`
`323`	`323`	`{`
`324`	`324`	`[NotNull]`
`325`	`325`	`public IOperation LeftArgument { get; }`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public override void Initialize([NotNull] AnalysisContext context)`
`42`	`42`
`43`	`43`	`private static void AnalyzeMember(SymbolAnalysisContext context)`
`44`	`44`	`{`
`45`		`- if (context.Symbol is INamedTypeSymbol typeSymbol && typeSymbol.ContainingType == null)`
	`45`	`+ if (context.Symbol is INamedTypeSymbol { ContainingType: null })`
`46`	`46`	`{`
`47`	`47`	`return;`
`48`	`48`	`}`