Introduce SafeSyntaxWalker

analyzers/src/SonarAnalyzer.CSharp/Helpers/CSharpIfDirectiveHelper.cs

@@ -24,7 +24,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using SonarAnalyzer.Extensions;
 
 namespace SonarAnalyzer.Helpers
 {
@@ -114,7 +113,7 @@ private static IList<DirectiveTriviaSyntax> CollectPrecedingDirectiveSyntax(Synt
         /// Collects all of the #if, #else, #elsif and #endif directives occuring in the
         /// syntax tree up to the specified node
         /// </summary>
-        private class BranchingDirectiveCollector : CSharpSyntaxWalker
+        private sealed class BranchingDirectiveCollector : SafeCSharpSyntaxWalker
         {
             private readonly SyntaxNode terminatingNode;
             private bool found;

analyzers/src/SonarAnalyzer.CSharp/Helpers/CSharpSymbolUsageCollector.cs

@@ -35,7 +35,7 @@ namespace SonarAnalyzer.Helpers
     /// Collects all symbol usages from a class declaration. Ignores symbols whose names are not present
     /// in the knownSymbolNames collection for performance reasons.
     /// </summary>
-    internal class CSharpSymbolUsageCollector : CSharpSyntaxWalker
+    internal class CSharpSymbolUsageCollector : SafeCSharpSyntaxWalker
     {
         [Flags]
         private enum SymbolAccess { None = 0, Read = 1, Write = 2, ReadWrite = Read | Write }
@@ -54,8 +54,8 @@ private enum SymbolAccess { None = 0, Read = 1, Write = 2, ReadWrite = Read | Wr
 
         public ISet<ISymbol> UsedSymbols { get; } = new HashSet<ISymbol>();
         public IDictionary<ISymbol, SymbolUsage> FieldSymbolUsages { get; } = new Dictionary<ISymbol, SymbolUsage>();
-        public HashSet<string> DebuggerDisplayValues { get; } = new HashSet<string>();
-        public Dictionary<IPropertySymbol, AccessorAccess> PropertyAccess { get; } = new Dictionary<IPropertySymbol, AccessorAccess>();
+        public HashSet<string> DebuggerDisplayValues { get; } = new();
+        public Dictionary<IPropertySymbol, AccessorAccess> PropertyAccess { get; } = new();
 
         public CSharpSymbolUsageCollector(Compilation compilation, IEnumerable<ISymbol> knownSymbols)
         {

analyzers/src/SonarAnalyzer.CSharp/Extensions/CSharpSyntaxWalkerExtensions.cs → analyzers/src/SonarAnalyzer.CSharp/Helpers/SafeCSharpSyntaxWalker.cs

@@ -21,16 +21,21 @@
 using System;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using SonarAnalyzer.Common;
 
-namespace SonarAnalyzer.Extensions
+namespace SonarAnalyzer.Helpers
 {
-    public static class CSharpSyntaxWalkerExtensions
+    public class SafeCSharpSyntaxWalker : CSharpSyntaxWalker, ISafeSyntaxWalker
     {
-        public static bool SafeVisit(this CSharpSyntaxWalker syntaxWalker, SyntaxNode syntaxNode)
+        protected SafeCSharpSyntaxWalker() { }
+
+        protected SafeCSharpSyntaxWalker(SyntaxWalkerDepth depth) : base(depth) { }
+
+        public bool SafeVisit(SyntaxNode syntaxNode)
         {
             try
             {
-                syntaxWalker.Visit(syntaxNode);
+                Visit(syntaxNode);
                 return true;
             }
             catch (InsufficientExecutionStackException)

analyzers/src/SonarAnalyzer.CSharp/Metrics/CSharpCognitiveComplexityMetric.cs

@@ -26,6 +26,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using SonarAnalyzer.Common;
 using SonarAnalyzer.Extensions;
+using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
 namespace SonarAnalyzer.Metrics.CSharp
@@ -43,12 +44,11 @@ public static CognitiveComplexity GetComplexity(SyntaxNode node, bool onlyGlobal
             return new CognitiveComplexity(walker.State.Complexity, walker.State.IncrementLocations.ToImmutableArray());
         }
 
-        private class CognitiveWalker : CSharpSyntaxWalker
+        private sealed class CognitiveWalker : SafeCSharpSyntaxWalker
         {
             private readonly bool onlyGlobalStatements;
 
-            public CognitiveComplexityWalkerState<MethodDeclarationSyntax> State { get; }
-                = new CognitiveComplexityWalkerState<MethodDeclarationSyntax>();
+            public CognitiveComplexityWalkerState<MethodDeclarationSyntax> State { get; } = new();
 
             public CognitiveWalker(bool onlyGlobalStatements) =>
                 this.onlyGlobalStatements = onlyGlobalStatements;

analyzers/src/SonarAnalyzer.CSharp/Metrics/CSharpCyclomaticComplexityMetric.cs

@@ -25,7 +25,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using SonarAnalyzer.Common;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -55,12 +54,11 @@ public static CyclomaticComplexity GetComplexity(SyntaxNode syntaxNode, bool onl
             return new CyclomaticComplexity(walker.IncrementLocations.ToImmutableArray());
         }
 
-        private class CyclomaticWalker : CSharpSyntaxWalker
+        private sealed class CyclomaticWalker : SafeCSharpSyntaxWalker
         {
             private readonly bool onlyGlobalStatements;
 
-            public List<SecondaryLocation> IncrementLocations { get; }
-                = new List<SecondaryLocation>();
+            public List<SecondaryLocation> IncrementLocations { get; } = new();
 
             public CyclomaticWalker(bool onlyGlobalStatements) =>
                 this.onlyGlobalStatements = onlyGlobalStatements;

analyzers/src/SonarAnalyzer.CSharp/Metrics/CSharpExecutableLinesMetric.cs

@@ -25,7 +25,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -43,7 +42,7 @@ public static ImmutableArray<int> GetLineNumbers(SyntaxTree syntaxTree, Semantic
             return walker.ExecutableLineNumbers.ToImmutableArray();
         }
 
-        private class ExecutableLinesWalker : CSharpSyntaxWalker
+        private sealed class ExecutableLinesWalker : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel semanticModel;
 
@@ -52,8 +51,7 @@ public ExecutableLinesWalker(SemanticModel semanticModel)
                 this.semanticModel = semanticModel;
             }
 
-            public HashSet<int> ExecutableLineNumbers { get; }
-                 = new HashSet<int>();
+            public HashSet<int> ExecutableLineNumbers { get; } = new();
 
             public override void DefaultVisit(SyntaxNode node)
             {

analyzers/src/SonarAnalyzer.CSharp/Rules/AvoidExcessiveClassCoupling.cs

@@ -26,7 +26,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using SonarAnalyzer.Common;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -140,7 +139,7 @@ private static IEnumerable<INamedTypeSymbol> ExpandGenericTypes(INamedTypeSymbol
         private static IEnumerable<INamedTypeSymbol> GetConstraintTypes(ITypeParameterSymbol typeParameter) =>
             typeParameter.ConstraintTypes.OfType<INamedTypeSymbol>().SelectMany(ExpandGenericTypes);
 
-        private class TypeDependencyCollector : CSharpSyntaxWalker
+        private sealed class TypeDependencyCollector : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel model;
             private readonly TypeDeclarationSyntax originalTypeDeclaration;

analyzers/src/SonarAnalyzer.CSharp/Rules/BeginInvokePairedWithEndInvoke.cs

@@ -105,7 +105,7 @@ private static SyntaxNode LookupIdentifierInitializer(IdentifierNameSyntax ident
                 ? equalsValueClause.Value.RemoveParentheses()
                 : null;
 
-        private class InvocationWalker : CSharpSyntaxWalker
+        private class InvocationWalker : SafeCSharpSyntaxWalker
         {
             private readonly EndInvokeContext context;
 

analyzers/src/SonarAnalyzer.CSharp/Rules/ConsumeValueTaskCorrectly.cs

@@ -25,7 +25,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 
 namespace SonarAnalyzer.Rules.CSharp
@@ -84,7 +83,7 @@ protected override void Initialize(SonarAnalysisContext context)
                 SyntaxKind.MethodDeclaration);
         }
 
-        private class ConsumeValueTaskWalker : CSharpSyntaxWalker
+        private sealed class ConsumeValueTaskWalker : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel semanticModel;
 

analyzers/src/SonarAnalyzer.CSharp/Rules/DoNotCopyArraysInProperties.cs

@@ -25,7 +25,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -77,18 +76,18 @@ private static SyntaxNode GetPropertyBody(PropertyDeclarationSyntax property)
                     .FirstOrDefault();
         }
 
-        private class PropertyWalker : CSharpSyntaxWalker
+        private sealed class PropertyWalker : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel semanticModel;
-            private readonly List<Location> locations = new List<Location>();
+            private readonly List<Location> locations = new();
 
-            private static readonly HashSet<SyntaxKind> returnStatements = new HashSet<SyntaxKind>
+            private static readonly HashSet<SyntaxKind> ReturnStatements = new()
             {
                 SyntaxKind.ReturnStatement,
                 SyntaxKind.ArrowExpressionClause,
             };
 
-            public IEnumerable<Location> Locations => this.locations;
+            public IEnumerable<Location> Locations => locations;
 
             public PropertyWalker(SemanticModel semanticModel)
             {
@@ -127,7 +126,7 @@ private static bool IsReturnOrAssignment(SyntaxNode node)
 
             private static bool IsReturn(SyntaxNode node)
             {
-                return node != null && node.IsAnyKind(returnStatements);
+                return node != null && node.IsAnyKind(ReturnStatements);
             }
         }
     }

analyzers/src/SonarAnalyzer.CSharp/Rules/DoNotNestTypesInArguments.cs

@@ -25,7 +25,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -70,7 +69,7 @@ var wrapper when LocalFunctionStatementSyntaxWrapper.IsInstance(wrapper) => ((Lo
                 _ => Enumerable.Empty<ParameterSyntax>()
             };
 
-        private sealed class GenericWalker : CSharpSyntaxWalker
+        private sealed class GenericWalker : SafeCSharpSyntaxWalker
         {
             private static readonly ImmutableArray<KnownType> ignoredTypes =
                 KnownType.SystemFuncVariants

analyzers/src/SonarAnalyzer.CSharp/Rules/FunctionNestingDepth.cs

@@ -23,7 +23,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -51,7 +50,7 @@ protected override void Initialize(ParameterLoadingAnalysisContext context) =>
             SyntaxKind.RemoveAccessorDeclaration,
             SyntaxKind.GlobalStatement);
 
-        private class NestingDepthWalker : CSharpSyntaxWalker
+        private sealed class NestingDepthWalker : SafeCSharpSyntaxWalker
         {
             private readonly NestingDepthCounter counter;
 

analyzers/src/SonarAnalyzer.CSharp/Rules/Hotspots/InsecureDeserialization.cs

@@ -149,10 +149,10 @@ private static bool ImplementsIDeserializationCallback(ITypeSymbol symbol) =>
         /// This walker is responsible to visit all constructor declarations and check if parameters are used in a
         /// conditional structure or not.
         /// </summary>
-        private sealed class ConstructorDeclarationWalker : CSharpSyntaxWalker
+        private sealed class ConstructorDeclarationWalker : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel semanticModel;
-            private readonly List<ConstructorInfo> constructorsInfo = new List<ConstructorInfo>();
+            private readonly List<ConstructorInfo> constructorsInfo = new();
 
             private bool visitedFirstLevel;
 
@@ -237,7 +237,7 @@ private static ImmutableArray<ISymbol> GetConstructorParameterSymbols(BaseMethod
         /// This walker is responsible to visit all conditional structures and check if a list of parameters
         /// are used or not.
         /// </summary>
-        private sealed class ConditionalsWalker : CSharpSyntaxWalker
+        private sealed class ConditionalsWalker : SafeCSharpSyntaxWalker
         {
             private readonly SemanticModel semanticModel;
             private readonly ISet<string> parameterNames;

analyzers/src/SonarAnalyzer.CSharp/Rules/NoExceptionsInFinally.cs

@@ -22,7 +22,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 
 namespace SonarAnalyzer.Rules.CSharp
@@ -37,7 +36,7 @@ protected override void Initialize(SonarAnalysisContext context) =>
                 c => new ThrowInFinallyWalker(c, Rule).SafeVisit(((FinallyClauseSyntax)c.Node).Block),
                 SyntaxKind.FinallyClause);
 
-        private class ThrowInFinallyWalker : CSharpSyntaxWalker
+        private sealed class ThrowInFinallyWalker : SafeCSharpSyntaxWalker
         {
             private readonly SyntaxNodeAnalysisContext context;
             private readonly DiagnosticDescriptor rule;

analyzers/src/SonarAnalyzer.CSharp/Rules/ParameterValidationInMethodWalker.cs

@@ -27,7 +27,7 @@
 
 namespace SonarAnalyzer.Rules.CSharp
 {
-    internal class ParameterValidationInMethodWalker : CSharpSyntaxWalker
+    internal class ParameterValidationInMethodWalker : SafeCSharpSyntaxWalker
     {
         private static readonly ISet<SyntaxKind> SubMethodEquivalents =
             new HashSet<SyntaxKind>
@@ -38,11 +38,11 @@ internal class ParameterValidationInMethodWalker : CSharpSyntaxWalker
             };
 
         private readonly SemanticModel semanticModel;
-        private readonly List<Location> argumentExceptionLocations = new List<Location>();
+        private readonly List<Location> argumentExceptionLocations = new();
 
         private bool keepWalking = true;
 
-        public IEnumerable<Location> ArgumentExceptionLocations => this.argumentExceptionLocations;
+        public IEnumerable<Location> ArgumentExceptionLocations => argumentExceptionLocations;
 
         public ParameterValidationInMethodWalker(SemanticModel semanticModel)
         {

analyzers/src/SonarAnalyzer.CSharp/Rules/PrivateFieldUsedAsLocalVariable.cs

@@ -104,21 +104,18 @@ bool HasNoAttributes(FieldDeclarationSyntax fieldDeclaration) =>
                 fieldDeclaration.AttributeLists.Count == 0;
         }
 
-        private class FieldAccessCollector : CSharpSyntaxWalker
+        private class FieldAccessCollector : SafeCSharpSyntaxWalker
         {
             // Contains statements that READ field values. First grouped by field symbol (that is read),
             // then by method/property/ctor symbol (that contains the statements)
-            private readonly Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>> readsByField =
-                new Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>>();
+            private readonly Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>> readsByField = new();
 
             // Contains statements that WRITE field values. First grouped by field symbol (that is written),
             // then by method/property/ctor symbol (that contains the statements)
-            private readonly Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>> writesByField =
-                new Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>>();
+            private readonly Dictionary<IFieldSymbol, Lookup<ISymbol, SyntaxNode>> writesByField = new();
 
             // Contains all method/property invocations grouped by the statement that contains them.
-            private readonly Lookup<SyntaxNode, ISymbol> invocations =
-                new Lookup<SyntaxNode, ISymbol>();
+            private readonly Lookup<SyntaxNode, ISymbol> invocations = new();
 
             private readonly SemanticModel semanticModel;
             private readonly IDictionary<IFieldSymbol, VariableDeclaratorSyntax> privateFields;

analyzers/src/SonarAnalyzer.CSharp/Rules/RedundantModifier.cs

@@ -26,7 +26,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -282,7 +281,7 @@ private static void CheckSealedMemberInSealedClass(SyntaxNodeAnalysisContext con
             }
         }
 
-        private class CheckedWalker : CSharpSyntaxWalker
+        private sealed class CheckedWalker : SafeCSharpSyntaxWalker
         {
             private readonly SyntaxNodeAnalysisContext context;
 

analyzers/src/SonarAnalyzer.CSharp/Rules/SqlKeywordsDelimitedBySpace.cs

@@ -111,7 +111,7 @@ private bool HasSqlNamespace(SyntaxList<UsingDirectiveSyntax> usings) =>
             usings.Select(usingDirective => usingDirective.Name)
                 .Any(name => SqlNamespaces.Any(sn => SyntaxFactory.AreEquivalent(name, sn)));
 
-        private class StringConcatenationWalker : CSharpSyntaxWalker
+        private class StringConcatenationWalker : SafeCSharpSyntaxWalker
         {
             private readonly SyntaxNodeAnalysisContext context;
 

analyzers/src/SonarAnalyzer.CSharp/Rules/UnconditionalJumpStatement.cs

@@ -24,7 +24,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using SonarAnalyzer.Extensions;
 using SonarAnalyzer.Helpers;
 using StyleCop.Analyzers.Lightup;
 
@@ -100,7 +99,7 @@ protected override bool TryGetTryAncestorStatements(StatementSyntax node, List<S
                 return true;
             }
 
-            private class CsLoopwalker : CSharpSyntaxWalker
+            private sealed class CsLoopwalker : SafeCSharpSyntaxWalker
             {
                 private readonly LoopWalker walker;