Merge next

Author: comintern

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/CodePathAnalysis/Nodes/IBranchNode.cs

@@ -0,0 +1,6 @@
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public interface IBranchNode : INode
+    {
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/ILoopNode.cs

@@ -0,0 +1,6 @@
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public interface ILoopNode : INode
+    {
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/INode.cs

@@ -0,0 +1,15 @@
+using Rubberduck.Parsing.Symbols;
+using System.Collections.Immutable;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public interface INode
+    {
+        int SortOrder { get; set; }
+        ImmutableList<INode> Children { get; set; }
+        INode Parent { get; set; }
+
+        Declaration Declaration { get; set; }
+        IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/AssignmentNode.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class AssignmentNode : INode
+    {
+        public AssignmentNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/BlockNode.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class BlockNode : INode
+    {
+        public BlockNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/BranchNode.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class BranchNode : IBranchNode
+    {
+        public BranchNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/DeclarationNode.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class DeclarationNode : INode
+    {
+        public DeclarationNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/GenericNode.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class GenericNode : INode
+    {
+        public GenericNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Implementations/LoopNode.cs

@@ -0,0 +1,21 @@
+using Rubberduck.Parsing.Symbols;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class LoopNode : ILoopNode
+    {
+        public LoopNode()
+        {
+            Children = new List<INode>().ToImmutableList();
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}