Dyn-3640 - Recover execution after clearing cyclic dependency from graph

src/DynamoCore/Graph/Workspaces/WorkspaceModel.cs

@@ -1267,6 +1267,9 @@ internal void AddAndRegisterNode(NodeModel node, bool centered = false)
 
             HasUnsavedChanges = true;
 
+            if (node is CodeBlockNodeModel cbn
+                && string.IsNullOrEmpty(cbn.Code)) return;
+
             RequestRun();
         }
 

src/Engine/ProtoAssociative/CodeGen.cs

@@ -330,7 +330,8 @@ private List<GraphNode> StrongConnectComponent(GraphNode node, ref int index, Di
             return null;
         }
 
-        private bool CyclicDependencyTest(ProtoCore.AssociativeGraph.GraphNode node, ref SymbolNode cyclicSymbol1, ref SymbolNode cyclicSymbol2)
+        // Returns true if there is no cyclic dependency, returns false otherwise.
+        private bool CyclicDependencyTest(GraphNode node, ref SymbolNode cyclicSymbol1, ref SymbolNode cyclicSymbol2)
         {
             if (null == node || node.updateNodeRefList.Count == 0)
             {
@@ -339,16 +340,15 @@ private bool CyclicDependencyTest(ProtoCore.AssociativeGraph.GraphNode node, ref
 
             var indexMap = new Dictionary<GraphNode, int>();
             var lowlinkMap = new Dictionary<GraphNode, int>();
-            var S = new Stack<GraphNode>();
+            var s = new Stack<GraphNode>();
             int index = 0;
 
-            for (int n = 0; n < codeBlock.instrStream.dependencyGraph.GraphList.Count; ++n)
+            foreach (var subNode in codeBlock.instrStream.dependencyGraph.GraphList)
             {
-                ProtoCore.AssociativeGraph.GraphNode subNode = codeBlock.instrStream.dependencyGraph.GraphList[n];
                 indexMap[subNode] = Constants.kInvalidIndex;
             }
 
-            var dependencyList = StrongConnectComponent(node, ref index, lowlinkMap, indexMap, S);
+            var dependencyList = StrongConnectComponent(node, ref index, lowlinkMap, indexMap, s);
             if (dependencyList == null)
             {
                 return true;
@@ -360,7 +360,7 @@ private bool CyclicDependencyTest(ProtoCore.AssociativeGraph.GraphNode node, ref
 
                 foreach (var n in dependencyList.GroupBy(x => x.guid).Select(y => y.First()))
                 {
-                    core.BuildStatus.LogWarning(ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency,
+                    core.BuildStatus.LogWarning(WarningID.InvalidStaticCyclicDependency,
                         ProtoCore.Properties.Resources.kInvalidStaticCyclicDependency, core.CurrentDSFileName, graphNode: n);
                 }
                 firstNode.isCyclic = true;
@@ -5467,6 +5467,8 @@ private void EmitBinaryExpressionNode(AssociativeNode node, ref ProtoCore.Type i
                     {
                         if (!CyclicDependencyTest(graphNode, ref cyclicSymbol1, ref cyclicSymbol2))
                         {
+                            //buildStatus.LogSemanticError("cyclic dependency", core.CurrentDSFileName, node.line, node.col, graphNode);
+
                             Validity.Assert(null != cyclicSymbol1);
                             Validity.Assert(null != cyclicSymbol2);
 

src/Engine/ProtoCore/AssociativeGraph.cs

@@ -892,8 +892,8 @@ public class GraphNode
         ///     a = b.c.d
         ///     
         ///     [0] t0 = b      -> List empty
-        ///     [1] t1 = t0.b   -> List empty
-        ///     [2] t2 = t1.c   -> List empty
+        ///     [1] t1 = t0.c   -> List empty
+        ///     [2] t2 = t1.d   -> List empty
         ///     [3] a = t2      -> This is the last SSA stmt, its graphnode contains a list of graphnodes {t0,t1,t2}
         ///     
         /// </summary>
@@ -961,6 +961,37 @@ public void PushChildNode(GraphNode child)
             child.ParentNodes.Add(this);
         }
 
+        internal void ClearCycles(IEnumerable<GraphNode> graphNodes)
+        {
+            Stack<GraphNode> stack = new Stack<GraphNode>();
+            stack.Push(this);
+
+            var visited = graphNodes.ToDictionary(node => node, node => false);
+
+            while(stack.Any())
+            {
+                var node = stack.Pop();
+                if (!visited[node])
+                {
+                    if (node.isCyclic)
+                    {
+                        node.isCyclic = false;
+                        node.isActive = true;
+                    }
+
+                    visited[node] = true;
+                }
+
+                foreach(var cNode in node.ChildrenNodes)
+                {
+                    if (!visited[cNode])
+                    {
+                        stack.Push(cNode);
+                    }
+                }
+            }
+        }
+
         public void PushDependent(GraphNode dependent)
         {
             if (!allowDependents)
@@ -1447,7 +1478,7 @@ public class DependencyGraph
         private readonly Core core;
         private List<GraphNode> graphList;
 
-        // For quickly get a list of graph nodes at some scope. 
+        // Get a list of graph nodes at some scope. 
         private Dictionary<ulong, List<GraphNode>> graphNodeMap;
 
         public List<GraphNode> GraphList

src/Engine/ProtoCore/BuildStatus.cs

@@ -663,10 +663,6 @@ public void LogWarning(BuildData.WarningID warningID,
             };
             warnings.Add(entry);
 
-            if (core.Options.IsDeltaExecution)
-            {
-            }
-
             if (LogWarnings)
             {
 #if DEBUG

src/Engine/ProtoCore/DSASM/Executive.cs

@@ -1326,7 +1326,7 @@ private int UpdateGraph(int exprUID, bool isSSAAssign)
 
                     if (gnode.isCyclic)
                     {
-                        // If the graphnode is cyclic, mark it as not dirst so it wont get executed 
+                        // If the graphnode is cyclic, mark it as not dirty so it wont get executed 
                         // Sets its cyclePoint graphnode to be not dirty so it also doesnt execute.
                         // The cyclepoint is the other graphNode that the current node cycles with
                         gnode.isDirty = false;
@@ -1338,15 +1338,17 @@ private int UpdateGraph(int exprUID, bool isSSAAssign)
                     }
                 }
             }
-
             // Get all redefined graphnodes
             int classScope = Constants.kInvalidIndex;
             int functionScope = Constants.kInvalidIndex;
             GetCallerInformation(out classScope, out functionScope);
+
             var nodesInScope = istream.dependencyGraph.GetGraphNodesAtScope(classScope, functionScope);
+
             List<AssociativeGraph.GraphNode> redefinedNodes = 
                 AssociativeEngine.Utils.GetRedefinedGraphNodes(runtimeCore, Properties.executingGraphNode, nodesInScope, classScope, functionScope);
             Validity.Assert(redefinedNodes != null);
+
             foreach(AssociativeGraph.GraphNode gnode in redefinedNodes)
             {
                 // GC all the temporaries associated with the redefined variable

src/Engine/ProtoScript/Runners/LiveRunner.cs

@@ -224,6 +224,8 @@ private void ApplyChangeSetModified(ChangeSetData changeSet)
 
             DeactivateGraphnodes(changeSet.RemovedBinaryNodesFromModification);
 
+            ReActivateGraphNodesInCycle(changeSet.RemovedBinaryNodesFromModification);
+
             // Undefine a function that was removed 
             UndefineFunctions(changeSet.RemovedFunctionDefNodesFromModification);
 
@@ -254,6 +256,35 @@ private void ApplyChangeSetForceExecute(ChangeSetData changeSet)
             }
         }
 
+        private void ReActivateGraphNodesInCycle(List<AssociativeNode> nodeList)
+        {
+            var assocGraph = core.DSExecutable.instrStreamList[0].dependencyGraph;
+            var graphNodes = assocGraph.GetGraphNodesAtScope(Constants.kInvalidIndex, Constants.kInvalidIndex);
+
+            foreach (var node in nodeList)
+            {
+                var bNode = node as BinaryExpressionNode;
+                if (bNode == null) continue;
+
+                var identifier = bNode.LeftNode as IdentifierNode;
+                if (identifier == null) continue;
+
+                GraphNode rootNode = null;
+                foreach(var gNode in graphNodes)
+                {
+                    if(identifier.Value == gNode.updateNodeRefList[0].nodeList[0].symbol.name)
+                    {
+                        rootNode = gNode;
+                        break;
+                    }
+                }
+                if (rootNode == null) return;
+
+                // walk the dependency graph for the rootNode and clear cycles from dependent graph nodes
+                rootNode.ClearCycles(graphNodes);
+            }
+        }
+
         /// <summary>
         /// Deactivate a single graphnode regardless of its associated dependencies
         /// </summary>
@@ -1401,21 +1432,13 @@ private bool CompileAndExecute(List<AssociativeNode> astList)
         private void PostExecution()
         {
             ApplyUpdate();
-            HandleWarnings();
-        }
-
-        /// <summary>
-        /// Handle warnings that will be reported to the frontend
-        /// </summary>
-        private void HandleWarnings()
-        {
-            SuppressResovledUnboundVariableWarnings();
+            SuppressResolvedUnboundVariableWarnings();
         }
 
         /// <summary>
         /// Removes all warnings that were initially unbound variables but were resolved at runtime
         /// </summary>
-        private void SuppressResovledUnboundVariableWarnings()
+        private void SuppressResolvedUnboundVariableWarnings()
         {
             runnerCore.BuildStatus.RemoveUnboundVariableWarnings(runnerCore.DSExecutable.UpdatedSymbols);