Merge branch 'next' of https://github.com/rubberduck-vba/Rubberduck into CleanComSafeLeakRound2

Author: bclothier

Rubberduck.CodeAnalysis/CodePathAnalysis/Extensions/NodeExtensions.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Extensions
 {
@@ -50,5 +51,34 @@ public static INode GetFirstNode(this INode node, IEnumerable<Type> excludedType
 
             return GetFirstNode(node.Children[0], excludedTypes);
         }
+
+        public static List<IdentifierReference> GetIdentifierReferences(this INode node)
+        {
+            var nodes = new List<IdentifierReference>();
+
+            var blockNodes = node.GetNodes(new[] { typeof(BlockNode) });
+            foreach (var block in blockNodes)
+            {
+                INode lastNode = default;
+                foreach (var flattenedNode in block.GetFlattenedNodes(new[] { typeof(GenericNode), typeof(BlockNode) }))
+                {
+                    if (flattenedNode is AssignmentNode &&
+                        lastNode is AssignmentNode)
+                    {
+                        nodes.Add(lastNode.Reference);
+                    }
+
+                    lastNode = flattenedNode;
+                }
+
+                if (lastNode is AssignmentNode &&
+                    block.Children[0].GetFirstNode(new[] { typeof(GenericNode) }) is DeclarationNode)
+                {
+                    nodes.Add(lastNode.Reference);
+                }
+            }
+
+            return nodes;
+        }
     }
 }

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/Abstract/NodeBase.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Antlr4.Runtime.Tree;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
+{
+    public abstract class NodeBase : INode
+    {
+        protected NodeBase(IParseTree tree)
+        {
+            Children = new List<INode>().ToImmutableList();
+            ParseTree = tree;
+        }
+
+        public int SortOrder { get; set; }
+        public ImmutableList<INode> Children { get; set; }
+        public INode Parent { get; set; }
+        public IParseTree ParseTree { get; }
+        public Declaration Declaration { get; set; }
+        public IdentifierReference Reference { get; set; }
+    }
+}

Rubberduck.CodeAnalysis/CodePathAnalysis/Nodes/INode.cs

@@ -1,5 +1,6 @@
 using Rubberduck.Parsing.Symbols;
 using System.Collections.Immutable;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
@@ -8,7 +9,7 @@ public interface INode
         int SortOrder { get; set; }
         ImmutableList<INode> Children { get; set; }
         INode Parent { get; set; }
-
+        IParseTree ParseTree { get; }
         Declaration Declaration { get; set; }
         IdentifierReference Reference { get; set; }
     }

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

@@ -1,21 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Rubberduck.Parsing.Symbols;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class AssignmentNode : INode
+    public class AssignmentNode : NodeBase
     {
-        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; }
+        public AssignmentNode(IParseTree tree) : base(tree) { }
     }
 }

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

@@ -1,21 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Rubberduck.Parsing.Symbols;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class BlockNode : INode
+    public class BlockNode : NodeBase
     {
-        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; }
+        public BlockNode(IParseTree tree) : base(tree) { }
     }
 }

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

@@ -1,21 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Rubberduck.Parsing.Symbols;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class BranchNode : IBranchNode
+    public class BranchNode : NodeBase, 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; }
+        public BranchNode(IParseTree tree) : base(tree) { }
     }
 }

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

@@ -1,21 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Rubberduck.Parsing.Symbols;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class DeclarationNode : INode
+    public class DeclarationNode : NodeBase
     {
-        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; }
+        public DeclarationNode(IParseTree tree) : base(tree) { }
     }
 }

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

@@ -1,21 +1,9 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Rubberduck.Parsing.Symbols;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class GenericNode : INode
+    public class GenericNode : NodeBase
     {
-        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; }
+        public GenericNode(IParseTree tree) : base(tree) { }
     }
 }

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

@@ -1,21 +1,9 @@
-using Rubberduck.Parsing.Symbols;
-using System.Collections.Generic;
-using System.Collections.Immutable;
+using Antlr4.Runtime.Tree;
 
 namespace Rubberduck.Inspections.CodePathAnalysis.Nodes
 {
-    public class LoopNode : ILoopNode
+    public class LoopNode : NodeBase, 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; }
+        public LoopNode(IParseTree tree) : base(tree) { }
     }
 }

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

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