Control flow analysis and assignment not used inspection

Author: Hosch250

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

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

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public class ReferenceNode : INode
+    {
+        public ReferenceNode()
+        {
+            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; }
+    }
+}