Resolve merge conflicts

Author: IvenBach

Rubberduck.API/VBA/Parser.cs

@@ -12,11 +12,12 @@
 using Rubberduck.Parsing.Symbols.DeclarationLoaders;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.Symbols;
-using Rubberduck.Parsing.Symbols.ParsingExceptions;
 using Rubberduck.Parsing.UIContext;
 using Rubberduck.Parsing.VBA.ComReferenceLoading;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.Parsing.VBA.DeclarationResolving;
 using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions;
 using Rubberduck.Parsing.VBA.ReferenceManagement;
 using Rubberduck.Resources.Registration;
 using Rubberduck.VBEditor.ComManagement;

Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricBase.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.CodeAnalysis.CodeMetrics

Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricsAnalyst.cs

@@ -4,6 +4,7 @@
 using Rubberduck.VBEditor;
 using System.Collections.Generic;
 using System.Linq;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 
 namespace Rubberduck.CodeAnalysis.CodeMetrics
 {

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; }
+    }
+}