Clean up stuff per review

Author: Hosch250

Rubberduck.CodeAnalysis/CodePathAnalysis/Extensions/NodeExtensions.cs

@@ -0,0 +1,54 @@
+using Rubberduck.Inspections.CodePathAnalysis.Nodes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Extensions
+{
+    public static class NodeExtensions
+    {
+        public static IEnumerable<INode> GetFlattenedNodes(this INode node, IEnumerable<Type> excludedTypes)
+        {
+            foreach (var child in node.Children)
+            {
+                if (!excludedTypes.Contains(child.GetType()))
+                {
+                    yield return child;
+                }
+                else
+                {
+                    foreach (var nextChild in GetFlattenedNodes(child, excludedTypes))
+                    {
+                        yield return nextChild;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<INode> GetNodes(this INode node, IEnumerable<Type> types)
+        {
+            if (types.Contains(node.GetType()))
+            {
+                yield return node;
+            }
+
+            foreach (var child in node.Children)
+            {
+                foreach (var childNode in GetNodes(child, types))
+                {
+                    yield return childNode;
+                }
+            }
+        }
+
+        public static INode GetFirstNode(this INode node, IEnumerable<Type> excludedTypes)
+        {
+            if (!excludedTypes.Contains(node.GetType()))
+            {
+                return node;
+            }
+
+            return GetFirstNode(node.Children[0], excludedTypes);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -5,6 +5,7 @@
 using Rubberduck.Inspections.CodePathAnalysis;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Inspections.CodePathAnalysis.Nodes;
+using Rubberduck.Inspections.CodePathAnalysis.Extensions;
 using System.Linq;
 using Rubberduck.Inspections.Results;
 
@@ -28,23 +29,23 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             {
                 var tree = _walker.GenerateTree(variable.ParentScopeDeclaration.Context, variable);
 
-                nodes.AddRange(GetReferences(tree, variable));
+                nodes.AddRange(GetIdentifierReferences(tree, variable));
             }
 
             return nodes
                 .Select(issue => new IdentifierReferenceInspectionResult(this, Description, State, issue))
                 .ToList();
         }
 
-        private List<IdentifierReference> GetReferences(INode node, Declaration declaration)
+        private List<IdentifierReference> GetIdentifierReferences(INode node, Declaration declaration)
         {
             var nodes = new List<IdentifierReference>();
 
-            var blockNodes = GetBlocks(node);
+            var blockNodes = node.GetNodes(new[] { typeof(BlockNode) });
             foreach (var block in blockNodes)
             {
                 INode lastNode = default;
-                foreach (var flattenedNode in GetFlattenedNodes(block))
+                foreach (var flattenedNode in block.GetFlattenedNodes(new[] { typeof(GenericNode), typeof(BlockNode) }))
                 {
                     if (flattenedNode is AssignmentNode &&
                         lastNode is AssignmentNode)
@@ -56,59 +57,13 @@ private List<IdentifierReference> GetReferences(INode node, Declaration declarat
                 }
 
                 if (lastNode is AssignmentNode &&
-                    GetFirstNonGenericNode(block.Children[0]) is DeclarationNode)
+                    block.Children[0].GetFirstNode(new[] { typeof(GenericNode) }) is DeclarationNode)
                 {
                     nodes.Add(lastNode.Reference);
                 }
             }
 
             return nodes;
         }
-
-        private IEnumerable<INode> GetFlattenedNodes(INode node)
-        {
-            foreach (var child in node.Children)
-            {
-                switch (child)
-                {
-                    case GenericNode _:
-                    case BlockNode _:
-                        foreach (var nextChild in GetFlattenedNodes(child))
-                        {
-                            yield return nextChild;
-                        }
-                        break;
-                    default:
-                        yield return child;
-                        break;
-                }
-            }
-        }
-
-        private IEnumerable<INode> GetBlocks(INode node)
-        {
-            if (node is BlockNode)
-            {
-                yield return node;
-            }
-
-            foreach (var child in node.Children)
-            {
-                foreach (var block in GetBlocks(child))
-                {
-                    yield return block;
-                }
-            }
-        }
-
-        private INode GetFirstNonGenericNode(INode parent)
-        {
-            if (!(parent is GenericNode))
-            {
-                return parent;
-            }
-
-            return GetFirstNonGenericNode(parent.Children[0]);
-        }
     }
 }

Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj

@@ -71,6 +71,7 @@
     <Compile Include="CodeMetrics\CyclomaticComplexityMetric.cs" />
     <Compile Include="CodeMetrics\LineCountMetric.cs" />
     <Compile Include="CodeMetrics\NestingLevelMetric.cs" />
+    <Compile Include="CodePathAnalysis\Extensions\NodeExtensions.cs" />
     <Compile Include="CodePathAnalysis\Nodes\ILoopNode.cs" />
     <Compile Include="CodePathAnalysis\Nodes\Implementations\AssignmentNode.cs" />
     <Compile Include="CodePathAnalysis\Nodes\Implementations\BlockNode.cs" />