Merge pull request #2604 from sharwell/unnecessary-type-check

sharwell · web-flow · commit 41f6ff77f308 · 2018-01-28T15:47:55.000-06:00
Unnecessary type check
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1501StatementMustNotBeOnASingleLine.cs b/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1501StatementMustNotBeOnASingleLine.cs
@@ -97,9 +97,8 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
 
         private static void HandleBlock(SyntaxNodeAnalysisContext context)
         {
-            var block = context.Node as BlockSyntax;
-            if ((block != null) &&
-                !block.OpenBraceToken.IsMissing &&
+            var block = (BlockSyntax)context.Node;
+            if (!block.OpenBraceToken.IsMissing &&
                 !block.CloseBraceToken.IsMissing &&
                 IsPartOfStatement(block))
             {
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1516ElementsMustBeSeparatedByBlankLine.cs b/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1516ElementsMustBeSeparatedByBlankLine.cs
@@ -158,61 +158,52 @@ private static void HandleBasePropertyDeclaration(SyntaxNodeAnalysisContext cont
 
         private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
-            var typeDeclaration = context.Node as TypeDeclarationSyntax;
+            var typeDeclaration = (TypeDeclarationSyntax)context.Node;
 
-            if (typeDeclaration != null)
-            {
-                var members = typeDeclaration.Members;
+            var members = typeDeclaration.Members;
 
-                HandleMemberList(context, members);
-            }
+            HandleMemberList(context, members);
         }
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
-            var compilationUnit = context.Node as CompilationUnitSyntax;
+            var compilationUnit = (CompilationUnitSyntax)context.Node;
 
-            if (compilationUnit != null)
-            {
-                var usings = compilationUnit.Usings;
-                var members = compilationUnit.Members;
+            var usings = compilationUnit.Usings;
+            var members = compilationUnit.Members;
 
-                HandleUsings(context, usings, settings);
-                HandleMemberList(context, members);
+            HandleUsings(context, usings, settings);
+            HandleMemberList(context, members);
 
-                if (members.Count > 0 && compilationUnit.Usings.Count > 0)
-                {
-                    ReportIfThereIsNoBlankLine(context, usings[usings.Count - 1], members[0]);
-                }
+            if (members.Count > 0 && compilationUnit.Usings.Count > 0)
+            {
+                ReportIfThereIsNoBlankLine(context, usings[usings.Count - 1], members[0]);
+            }
 
-                if (compilationUnit.Usings.Count > 0 && compilationUnit.Externs.Count > 0)
-                {
-                    ReportIfThereIsNoBlankLine(context, compilationUnit.Externs[compilationUnit.Externs.Count - 1], compilationUnit.Usings[0]);
-                }
+            if (compilationUnit.Usings.Count > 0 && compilationUnit.Externs.Count > 0)
+            {
+                ReportIfThereIsNoBlankLine(context, compilationUnit.Externs[compilationUnit.Externs.Count - 1], compilationUnit.Usings[0]);
             }
         }
 
         private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
-            var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;
+            var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
 
-            if (namespaceDeclaration != null)
-            {
-                var usings = namespaceDeclaration.Usings;
-                var members = namespaceDeclaration.Members;
+            var usings = namespaceDeclaration.Usings;
+            var members = namespaceDeclaration.Members;
 
-                HandleUsings(context, usings, settings);
-                HandleMemberList(context, members);
+            HandleUsings(context, usings, settings);
+            HandleMemberList(context, members);
 
-                if (members.Count > 0 && namespaceDeclaration.Usings.Count > 0)
-                {
-                    ReportIfThereIsNoBlankLine(context, usings[usings.Count - 1], members[0]);
-                }
+            if (members.Count > 0 && namespaceDeclaration.Usings.Count > 0)
+            {
+                ReportIfThereIsNoBlankLine(context, usings[usings.Count - 1], members[0]);
+            }
 
-                if (namespaceDeclaration.Usings.Count > 0 && namespaceDeclaration.Externs.Count > 0)
-                {
-                    ReportIfThereIsNoBlankLine(context, namespaceDeclaration.Externs[namespaceDeclaration.Externs.Count - 1], namespaceDeclaration.Usings[0]);
-                }
+            if (namespaceDeclaration.Usings.Count > 0 && namespaceDeclaration.Externs.Count > 0)
+            {
+                ReportIfThereIsNoBlankLine(context, namespaceDeclaration.Externs[namespaceDeclaration.Externs.Count - 1], namespaceDeclaration.Usings[0]);
             }
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1119StatementMustNotUseUnnecessaryParenthesis.cs b/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1119StatementMustNotUseUnnecessaryParenthesis.cs
@@ -96,9 +96,9 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
 
         private static void HandleParenthesizedExpression(SyntaxNodeAnalysisContext context)
         {
-            var node = context.Node as ParenthesizedExpressionSyntax;
+            var node = (ParenthesizedExpressionSyntax)context.Node;
 
-            if (node != null && node.Expression != null)
+            if (node.Expression != null)
             {
                 if (!(node.Expression is BinaryExpressionSyntax)
                     && !(node.Expression is AssignmentExpressionSyntax)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1405DebugAssertMustProvideMessageText.cs b/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1405DebugAssertMustProvideMessageText.cs
@@ -54,7 +54,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
         {
-            HandleMethodCall(context, nameof(Debug.Assert), 1, Descriptor);
+            HandleInvocationExpression(context, nameof(Debug.Assert), 1, Descriptor);
         }
     }
 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1406DebugFailMustProvideMessageText.cs b/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1406DebugFailMustProvideMessageText.cs
@@ -55,7 +55,7 @@ public override void Initialize(AnalysisContext context)
         private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
         {
             // Debug.Fail is not available in a portable library. So no nameof(Debug.Fail) here
-            HandleMethodCall(context, "Fail", 0, Descriptor);
+            HandleInvocationExpression(context, "Fail", 0, Descriptor);
         }
     }
 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1410RemoveDelegateParenthesisWhenPossible.cs b/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1410RemoveDelegateParenthesisWhenPossible.cs
@@ -63,11 +63,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleAnonymousMethodExpression(SyntaxNodeAnalysisContext context)
         {
-            AnonymousMethodExpressionSyntax syntax = context.Node as AnonymousMethodExpressionSyntax;
-            if (syntax == null)
-            {
-                return;
-            }
+            var syntax = (AnonymousMethodExpressionSyntax)context.Node;
 
             // ignore if no parameter list exists
             if (syntax.ParameterList == null)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SystemDiagnosticsDebugDiagnosticBase.cs b/StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SystemDiagnosticsDebugDiagnosticBase.cs
@@ -22,11 +22,11 @@ internal abstract class SystemDiagnosticsDebugDiagnosticBase : DiagnosticAnalyze
         /// <param name="methodName">The method name that should be detected</param>
         /// <param name="parameterIndex">The index, the string parameter that should be checked, is at</param>
         /// <param name="descriptor">The descriptor of the diagnostic that should be added</param>
-        protected internal static void HandleMethodCall(SyntaxNodeAnalysisContext context, string methodName, int parameterIndex, DiagnosticDescriptor descriptor)
+        protected internal static void HandleInvocationExpression(SyntaxNodeAnalysisContext context, string methodName, int parameterIndex, DiagnosticDescriptor descriptor)
         {
-            var invocationExpressionSyntax = context.Node as InvocationExpressionSyntax;
-            var memberAccessExpressionSyntax = invocationExpressionSyntax?.Expression as MemberAccessExpressionSyntax;
-            var identifierNameSyntax = invocationExpressionSyntax?.Expression as IdentifierNameSyntax;
+            var invocationExpressionSyntax = (InvocationExpressionSyntax)context.Node;
+            var memberAccessExpressionSyntax = invocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
+            var identifierNameSyntax = invocationExpressionSyntax.Expression as IdentifierNameSyntax;
             var name = memberAccessExpressionSyntax?.Name?.Identifier.ValueText ?? identifierNameSyntax?.Identifier.ValueText;
             if (name == methodName)
             {
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1311StaticReadonlyFieldsMustBeginWithUpperCaseLetter.cs b/StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1311StaticReadonlyFieldsMustBeginWithUpperCaseLetter.cs
@@ -50,11 +50,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleFieldDeclaration(SyntaxNodeAnalysisContext context)
         {
-            var fieldDeclaration = context.Node as FieldDeclarationSyntax;
-            if (fieldDeclaration == null)
-            {
-                return;
-            }
+            var fieldDeclaration = (FieldDeclarationSyntax)context.Node;
 
             if (!fieldDeclaration.Modifiers.Any(SyntaxKind.StaticKeyword) ||
                !fieldDeclaration.Modifiers.Any(SyntaxKind.ReadOnlyKeyword))
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.cs
@@ -62,7 +62,7 @@ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, Sty
                 return;
             }
 
-            var compilationUnit = context.Node as CompilationUnitSyntax;
+            var compilationUnit = (CompilationUnitSyntax)context.Node;
 
             var usings = compilationUnit.Usings;
 
@@ -76,7 +76,7 @@ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context
                 return;
             }
 
-            var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;
+            var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
 
             var usings = namespaceDeclaration.Usings;
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1209UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1209UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives.cs
@@ -55,14 +55,14 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
         {
-            var compilationUnit = context.Node as CompilationUnitSyntax;
+            var compilationUnit = (CompilationUnitSyntax)context.Node;
 
             ProcessUsingsAndReportDiagnostic(compilationUnit.Usings, context);
         }
 
         private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
         {
-            var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;
+            var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
 
             ProcessUsingsAndReportDiagnostic(namespaceDeclaration.Usings, context);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1211UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1211UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName.cs
@@ -55,20 +55,14 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
         {
-            var compilationUnit = context.Node as CompilationUnitSyntax;
-            if (compilationUnit != null)
-            {
-                HandleUsingDirectives(context, compilationUnit.Usings);
-            }
+            var compilationUnit = (CompilationUnitSyntax)context.Node;
+            HandleUsingDirectives(context, compilationUnit.Usings);
         }
 
         private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
         {
-            var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;
-            if (namespaceDeclaration != null)
-            {
-                HandleUsingDirectives(context, namespaceDeclaration.Usings);
-            }
+            var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
+            HandleUsingDirectives(context, namespaceDeclaration.Usings);
         }
 
         private static void HandleUsingDirectives(SyntaxNodeAnalysisContext context, SyntaxList<UsingDirectiveSyntax> usingDirectives)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1107CodeMustNotContainMultipleStatementsOnOneLine.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1107CodeMustNotContainMultipleStatementsOnOneLine.cs
@@ -51,9 +51,9 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleBlock(SyntaxNodeAnalysisContext context)
         {
-            BlockSyntax block = context.Node as BlockSyntax;
+            var block = (BlockSyntax)context.Node;
 
-            if (block != null && block.Statements.Any())
+            if (block.Statements.Any())
             {
                 var previousStatement = block.Statements[0];
                 FileLinePositionSpan previousStatementLocation = previousStatement.GetLineSpan();

Original file line number	Diff line number	Diff line change
`@@ -97,9 +97,8 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte`
`97`	`97`
`98`	`98`	`private static void HandleBlock(SyntaxNodeAnalysisContext context)`
`99`	`99`	`{`
`100`		`- var block = context.Node as BlockSyntax;`
`101`		`- if ((block != null) &&`
`102`		`- !block.OpenBraceToken.IsMissing &&`
	`100`	`+ var block = (BlockSyntax)context.Node;`
	`101`	`+ if (!block.OpenBraceToken.IsMissing &&`
`103`	`102`	`!block.CloseBraceToken.IsMissing &&`
`104`	`103`	`IsPartOfStatement(block))`
`105`	`104`	`{`
Original file line number	Diff line number	Diff line change
`@@ -96,9 +96,9 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte`
`96`	`96`
`97`	`97`	`private static void HandleParenthesizedExpression(SyntaxNodeAnalysisContext context)`
`98`	`98`	`{`
`99`		`- var node = context.Node as ParenthesizedExpressionSyntax;`
	`99`	`+ var node = (ParenthesizedExpressionSyntax)context.Node;`
`100`	`100`
`101`		`- if (node != null && node.Expression != null)`
	`101`	`+ if (node.Expression != null)`
`102`	`102`	`{`
`103`	`103`	`if (!(node.Expression is BinaryExpressionSyntax)`
`104`	`104`	`&& !(node.Expression is AssignmentExpressionSyntax)`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public override void Initialize(AnalysisContext context)`
`54`	`54`
`55`	`55`	`private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)`
`56`	`56`	`{`
`57`		`- HandleMethodCall(context, nameof(Debug.Assert), 1, Descriptor);`
	`57`	`+ HandleInvocationExpression(context, nameof(Debug.Assert), 1, Descriptor);`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public override void Initialize(AnalysisContext context)`
`55`	`55`	`private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)`
`56`	`56`	`{`
`57`	`57`	`// Debug.Fail is not available in a portable library. So no nameof(Debug.Fail) here`
`58`		`- HandleMethodCall(context, "Fail", 0, Descriptor);`
	`58`	`+ HandleInvocationExpression(context, "Fail", 0, Descriptor);`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, Sty`
`62`	`62`	`return;`
`63`	`63`	`}`
`64`	`64`
`65`		`- var compilationUnit = context.Node as CompilationUnitSyntax;`
	`65`	`+ var compilationUnit = (CompilationUnitSyntax)context.Node;`
`66`	`66`
`67`	`67`	`var usings = compilationUnit.Usings;`
`68`	`68`
`@@ -76,7 +76,7 @@ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context`
`76`	`76`	`return;`
`77`	`77`	`}`
`78`	`78`
`79`		`- var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;`
	`79`	`+ var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;`
`80`	`80`
`81`	`81`	`var usings = namespaceDeclaration.Usings;`
`82`	`82`
Original file line number	Diff line number	Diff line change
`@@ -55,14 +55,14 @@ public override void Initialize(AnalysisContext context)`
`55`	`55`
`56`	`56`	`private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)`
`57`	`57`	`{`
`58`		`- var compilationUnit = context.Node as CompilationUnitSyntax;`
	`58`	`+ var compilationUnit = (CompilationUnitSyntax)context.Node;`
`59`	`59`
`60`	`60`	`ProcessUsingsAndReportDiagnostic(compilationUnit.Usings, context);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)`
`64`	`64`	`{`
`65`		`- var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;`
	`65`	`+ var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;`
`66`	`66`
`67`	`67`	`ProcessUsingsAndReportDiagnostic(namespaceDeclaration.Usings, context);`
`68`	`68`	`}`