DynamoDS
diff --git a/‎src/DynamoCore/Graph/Nodes/CodeBlockNode.cs
Copy file name to clipboard
+1-52Lines changed: 1 addition & 52 deletions b/‎src/DynamoCore/Graph/Nodes/CodeBlockNode.cs
Copy file name to clipboard
+1-52Lines changed: 1 addition & 52 deletions
diff --git a/‎src/Engine/ProtoCore/AssociativeGraph.cs
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions b/‎src/Engine/ProtoCore/AssociativeGraph.cs
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions
diff --git a/‎src/Engine/ProtoCore/DSASM/Executive.cs
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions b/‎src/Engine/ProtoCore/DSASM/Executive.cs
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions
diff --git a/‎src/Engine/ProtoCore/SyntaxAnalysis/AssociativeAstVisitor.cs
Copy file name to clipboard
+82Lines changed: 82 additions & 0 deletions b/‎src/Engine/ProtoCore/SyntaxAnalysis/AssociativeAstVisitor.cs
Copy file name to clipboard
+82Lines changed: 82 additions & 0 deletions
diff --git a/‎src/Engine/ProtoCore/SyntaxAnalysis/ImperativeAstVisitor.cs
Copy file name to clipboard
+88-2Lines changed: 88 additions & 2 deletions b/‎src/Engine/ProtoCore/SyntaxAnalysis/ImperativeAstVisitor.cs
Copy file name to clipboard
+88-2Lines changed: 88 additions & 2 deletions
diff --git a/‎src/Engine/ProtoImperative/CodeGen.cs
Copy file name to clipboard
+3-23Lines changed: 3 additions & 23 deletions b/‎src/Engine/ProtoImperative/CodeGen.cs
Copy file name to clipboard
+3-23Lines changed: 3 additions & 23 deletions
diff --git a/‎test/DynamoCoreTests/CodeBlockNodeTests.cs
Copy file name to clipboard
+25Lines changed: 25 additions & 0 deletions b/‎test/DynamoCoreTests/CodeBlockNodeTests.cs
Copy file name to clipboard
+25Lines changed: 25 additions & 0 deletions
@@ -1236,58 +1236,7 @@ private string LocalizeIdentifier(string identifierName)
             return string.Format("{0}_{1}", identifierName, AstIdentifierGuid);
         }
 
-        private class ImperativeIdentifierInPlaceMapper : ImperativeAstReplacer
-        {
-            private ProtoCore.Core core;
-            private Func<string, bool> cond;
-            private Func<string, string> mapper;
-
-            public ImperativeIdentifierInPlaceMapper(ProtoCore.Core core, Func<string, bool> cond, Func<string, string> mapper)
-            {
-                this.core = core;
-                this.cond = cond;
-                this.mapper = mapper;
-            }
-
-            public override ProtoCore.AST.ImperativeAST.ImperativeNode VisitIdentifierNode(ProtoCore.AST.ImperativeAST.IdentifierNode node)
-            {
-                var variable = node.Value;
-                if (cond(variable))
-                    node.Value = node.Name = mapper(variable);
-
-                return base.VisitIdentifierNode(node);
-            }
-
-            public override ProtoCore.AST.ImperativeAST.ImperativeNode VisitIdentifierListNode(ProtoCore.AST.ImperativeAST.IdentifierListNode node)
-            {
-                node.LeftNode = node.LeftNode.Accept(this);
-
-                var rightNode = node.RightNode;
-                while (rightNode != null)
-                {
-                    if (rightNode is ProtoCore.AST.ImperativeAST.FunctionCallNode)
-                    {
-                        var funcCall = rightNode as ProtoCore.AST.ImperativeAST.FunctionCallNode;
-                        funcCall.FormalArguments = VisitNodeList(funcCall.FormalArguments);
-                        if (funcCall.ArrayDimensions != null)
-                        {
-                            funcCall.ArrayDimensions = funcCall.ArrayDimensions.Accept(this) as ProtoCore.AST.ImperativeAST.ArrayNode;
-                        }
-                        break;
-                    }
-                    else if (rightNode is ProtoCore.AST.ImperativeAST.IdentifierListNode)
-                    {
-                        rightNode = (rightNode as ProtoCore.AST.ImperativeAST.IdentifierListNode).RightNode;
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-
-                return node;
-            }
-        }
+        
 
         private class IdentifierInPlaceMapper : AstReplacer
         {
 
@@ -39,6 +39,7 @@ public static AssociativeGraph.GraphNode GetFirstDirtyGraphNodeFromPC(int pc, Li
         /// </summary>
         /// <param name="block"></param>
         /// <param name="graphNodesInScope"></param>
+        [Obsolete("This method is deprecated and will be removed in a future Dynamo version.")]
         public static void MarkAllGraphNodesDirty(int block, List<AssociativeGraph.GraphNode> graphNodesInScope)
         {
             if (graphNodesInScope != null)
@@ -53,6 +54,21 @@ public static void MarkAllGraphNodesDirty(int block, List<AssociativeGraph.Graph
             }
         }
 
+        /// <summary>
+        /// Marks all graphnodes in the scope dirty.
+        /// </summary>
+        /// <param name="graphNodesInScope"></param>
+        internal static void MarkAllGraphNodesDirty(List<AssociativeGraph.GraphNode> graphNodesInScope)
+        {
+            if (graphNodesInScope != null)
+            {
+                foreach (AssociativeGraph.GraphNode gnode in graphNodesInScope)
+                {
+                    gnode.isDirty = true;
+                }
+            }
+        }
+
         /// <summary>
         /// Builds the dependencies within the list of graphNodes
         /// </summary>
 
@@ -423,7 +423,7 @@ private void SetupEntryPoint()
             //  Entering a nested block requires all the nodes of that block to be executed
             if (executingBlock > 0)
             {
-                ProtoCore.AssociativeEngine.Utils.MarkAllGraphNodesDirty(executingBlock, graphNodesInProgramScope);
+                ProtoCore.AssociativeEngine.Utils.MarkAllGraphNodesDirty(graphNodesInProgramScope);
             }
 
             if (fepRun)
@@ -1227,9 +1227,7 @@ private void SetupGraphEntryPoint(int entrypoint, bool isGlobalScope)
 
                 if (runtimeCore.Options.IsDeltaExecution)
                 {
-                    // COmment Jun: start from graphnodes whose update blocks are in the range of the entry point
-                    bool inStartRange = graphNode.updateBlock.startpc >= entrypoint;
-                    if (graphNode.isDirty && inStartRange)
+                    if (graphNode.isDirty)
                     {
                         pc = graphNode.updateBlock.startpc;
                         graphNode.isDirty = false;
 
@@ -432,13 +432,95 @@ public virtual TResult VisitDefaultArgNode(DefaultArgNode node)
         }
     }
 
+    internal class AssociativeIdentifierInPlaceMapper : AssociativeAstReplacer
+    {
+        private Core core;
+        private Func<string, bool> cond;
+        private Func<string, string> mapper;
+
+        public AssociativeIdentifierInPlaceMapper(Core core, Func<string, bool> cond, Func<string, string> mapper)
+        {
+            this.core = core;
+            this.cond = cond;
+            this.mapper = mapper;
+        }
+
+        public override AssociativeNode VisitLanguageBlockNode(LanguageBlockNode node)
+        {
+            var cbn = node.CodeBlockNode as CodeBlockNode;
+            if (cbn == null)
+            {
+                var imperative_cbn = node.CodeBlockNode as AST.ImperativeAST.CodeBlockNode;
+                if (imperative_cbn != null)
+                {
+                    var replacer = new ImperativeIdentifierInPlaceMapper(core, cond, mapper);
+                    imperative_cbn = imperative_cbn.Accept(replacer) as AST.ImperativeAST.CodeBlockNode;
+                    return node;
+                }
+                else
+                {
+                    return base.VisitLanguageBlockNode(node);
+                }
+            }
+
+            var nodeList = cbn.Body.Select(astNode => astNode.Accept(this)).ToList();
+            cbn.Body = nodeList;
+            return node;
+        }
+
+        public override AssociativeNode VisitIdentifierNode(IdentifierNode node)
+        {
+            var variable = node.Value;
+            if (cond(variable))
+                node.Value = node.Name = mapper(variable);
+
+            return base.VisitIdentifierNode(node);
+        }
+
+        public override AssociativeNode VisitIdentifierListNode(IdentifierListNode node)
+        {
+            node.LeftNode = node.LeftNode.Accept(this);
+
+            var rightNode = node.RightNode;
+            while (rightNode != null)
+            {
+                if (rightNode is FunctionCallNode)
+                {
+                    var funcCall = rightNode as FunctionCallNode;
+                    funcCall.FormalArguments = VisitNodeList(funcCall.FormalArguments);
+                    if (funcCall.ArrayDimensions != null)
+                    {
+                        funcCall.ArrayDimensions = funcCall.ArrayDimensions.Accept(this) as ArrayNode;
+                    }
+                    break;
+                }
+                else if (rightNode is IdentifierListNode)
+                {
+                    rightNode = (rightNode as IdentifierListNode).RightNode;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return node;
+        }
+    }
+
     public class AssociativeAstReplacer : AssociativeAstVisitor<AssociativeNode>
     {
         public override AssociativeNode DefaultVisit(AssociativeNode node)
         {
             return node;
         }
 
+        public override AssociativeNode VisitCodeBlockNode(CodeBlockNode node)
+        {
+            node.Body = VisitNodeList(node.Body);
+            return node;
+        }
+
         public List<AssociativeNode> VisitNodeList(List<AssociativeNode> nodes)
         {
             for (int i = 0; i < nodes.Count; ++i)
 
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using ProtoCore.AST;
 using ProtoCore.AST.ImperativeAST;
@@ -345,6 +346,82 @@ public virtual TResult VisitIfStmtPositionNode(IfStmtPositionNode node)
         }
     }
 
+    internal class ImperativeIdentifierInPlaceMapper : ImperativeAstReplacer
+    {
+        private Core core;
+        private Func<string, bool> cond;
+        private Func<string, string> mapper;
+
+        public ImperativeIdentifierInPlaceMapper(Core core, Func<string, bool> cond, Func<string, string> mapper)
+        {
+            this.core = core;
+            this.cond = cond;
+            this.mapper = mapper;
+        }
+
+        public override ImperativeNode VisitLanguageBlockNode(LanguageBlockNode node)
+        {
+            var cbn = node.CodeBlockNode as CodeBlockNode;
+            if (cbn == null)
+            {
+                var assoc_cbn = node.CodeBlockNode as AST.AssociativeAST.CodeBlockNode;
+                if (assoc_cbn != null)
+                {
+                    var replacer = new AssociativeIdentifierInPlaceMapper(core, cond, mapper);
+                    assoc_cbn = assoc_cbn.Accept(replacer) as AST.AssociativeAST.CodeBlockNode;
+                    return node;
+                }
+                else
+                {
+                    return base.VisitLanguageBlockNode(node);
+                }
+            }
+
+            var nodeList = cbn.Body.Select(astNode => astNode.Accept(this)).ToList();
+            cbn.Body = nodeList;
+            return node;
+        }
+
+        public override ImperativeNode VisitIdentifierNode(IdentifierNode node)
+        {
+            var variable = node.Value;
+            if (cond(variable))
+                node.Value = node.Name = mapper(variable);
+
+            return base.VisitIdentifierNode(node);
+        }
+
+        public override ImperativeNode VisitIdentifierListNode(IdentifierListNode node)
+        {
+            node.LeftNode = node.LeftNode.Accept(this);
+
+            var rightNode = node.RightNode;
+            while (rightNode != null)
+            {
+                if (rightNode is FunctionCallNode)
+                {
+                    var funcCall = rightNode as FunctionCallNode;
+                    funcCall.FormalArguments = VisitNodeList(funcCall.FormalArguments);
+                    if (funcCall.ArrayDimensions != null)
+                    {
+                        funcCall.ArrayDimensions = funcCall.ArrayDimensions.Accept(this) as ArrayNode;
+                    }
+                    break;
+                }
+                else if (rightNode is IdentifierListNode)
+                {
+                    rightNode = (rightNode as IdentifierListNode).RightNode;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return node;
+        }
+    }
+
     public class ImperativeAstReplacer : ImperativeAstVisitor<ImperativeNode>
     {
         public override ImperativeNode DefaultVisit(ImperativeNode node)
@@ -357,7 +434,16 @@ public override ImperativeNode VisitLanguageBlockNode(LanguageBlockNode node)
             var cbn = node.CodeBlockNode as CodeBlockNode;
             if (cbn == null)
             {
-                return base.VisitLanguageBlockNode(node);
+                var assoc_cbn = node.CodeBlockNode as AST.AssociativeAST.CodeBlockNode;
+                if (assoc_cbn != null)
+                {
+                    var replacer = new AssociativeAstReplacer();
+                    assoc_cbn.Accept(replacer);
+                }
+                else
+                {
+                    return base.VisitLanguageBlockNode(node);
+                }
             }
 
             var nodeList = cbn.Body.Select(astNode => astNode.Accept(this)).ToList();
 
@@ -147,39 +147,19 @@ private SymbolNode Allocate(string ident, int funcIndex, ProtoCore.Type datatype
             if (core.ClassTable.IndexOf(ident) != ProtoCore.DSASM.Constants.kInvalidIndex)
                 buildStatus.LogSemanticError(String.Format(Resources.ClassNameAsVariableError,ident));
 
-            SymbolNode symbolnode;
-            if(cb == null)
-            {
-                 symbolnode = new SymbolNode(
+            SymbolNode symbolnode = new SymbolNode(
                  ident,
                  Constants.kInvalidIndex,
                  funcIndex,
                  datatype,
                  false,
-                 codeBlock.symbolTable.RuntimeIndex,
+                 cb == null ? codeBlock.symbolTable.RuntimeIndex : cb.symbolTable.RuntimeIndex,
                  MemoryRegion.MemStack,
                  globalClassIndex,
                  ProtoCore.CompilerDefinitions.AccessModifier.Public,
                  false,
-                 codeBlock.codeBlockId);
-            }
-            else
-            {
-               symbolnode = new SymbolNode(
-               ident,
-               Constants.kInvalidIndex,
-               funcIndex,
-               datatype,
-               false,
-               cb.symbolTable.RuntimeIndex,
-               MemoryRegion.MemStack,
-               globalClassIndex,
-               ProtoCore.CompilerDefinitions.AccessModifier.Public,
-               false,
-               cb.codeBlockId);
-            }
+                 cb == null ? codeBlock.codeBlockId : cb.codeBlockId);
 
-
             if (isEmittingImportNode)
                 symbolnode.ExternLib = core.CurrentDSFileName;
 
 
@@ -1472,6 +1472,30 @@ public void IntegerOverflow()
             AssertPreviewValue(mathCeiling.AstIdentifierGuid, long.MinValue);
         }
 
+        [Test]
+        public void NestedLangBlock_MultipleLevels()
+        {
+            OpenModel(Path.Combine(TestDirectory, @"core\dsevaluation\Nested_Language_Blocks.dyn"));
+
+            var cbn1 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block1");
+            var cbn2 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block2");
+            var cbn3 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block3");
+            var cbn4 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block4");
+            var cbn5 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block5");
+            var cbn6 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block6");
+            var cbn7 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block7");
+            var cbn8 = CurrentDynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.Name == "Code Block8");
+
+            AssertPreviewValue(cbn1.AstIdentifierGuid, new object[] { new[] { 0, 3, 6, 9, 12 }, 2.2 });
+            AssertPreviewValue(cbn2.AstIdentifierGuid, new object[] { new[] { 0, 1.5, 3, 4.5, 6 }, 2 });
+            AssertPreviewValue(cbn3.AstIdentifierGuid,  new[] { 0, 3, 6, 9, 12 });
+            AssertPreviewValue(cbn4.AstIdentifierGuid, new object[] { new[] { 0, 3, 6, 9, 12 }, 2 });
+            AssertPreviewValue(cbn5.AstIdentifierGuid, 13);
+            AssertPreviewValue(cbn6.AstIdentifierGuid, new[] { 323, 210, 325 });
+            AssertPreviewValue(cbn7.AstIdentifierGuid, new object[] { new[] { 0, 2, 4, 6, 8 }, 2.2 });
+            AssertPreviewValue(cbn8.AstIdentifierGuid, new object[] { new[] { 0, 2, 4, 6, 8 }, 2.2 });
+        }
+
         #region CodeBlockUtils Specific Tests
         [Test]
         [Category("UnitTests")]
@@ -1892,6 +1916,7 @@ private void UpdateCodeBlockNodeContent(CodeBlockNodeModel cbn, string value)
             var command = new DynCmd.UpdateModelValueCommand(Guid.Empty, cbn.GUID, "Code", value);
             CurrentDynamoModel.ExecuteCommand(command);
         }
+
     }
 
     [TestFixture]
Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ private void SetupEntryPoint()`
`423`	`423`	`// Entering a nested block requires all the nodes of that block to be executed`
`424`	`424`	`if (executingBlock > 0)`
`425`	`425`	`{`
`426`		`- ProtoCore.AssociativeEngine.Utils.MarkAllGraphNodesDirty(executingBlock, graphNodesInProgramScope);`
	`426`	`+ ProtoCore.AssociativeEngine.Utils.MarkAllGraphNodesDirty(graphNodesInProgramScope);`
`427`	`427`	`}`
`428`	`428`
`429`	`429`	`if (fepRun)`
`@@ -1227,9 +1227,7 @@ private void SetupGraphEntryPoint(int entrypoint, bool isGlobalScope)`
`1227`	`1227`
`1228`	`1228`	`if (runtimeCore.Options.IsDeltaExecution)`
`1229`	`1229`	`{`
`1230`		`- // COmment Jun: start from graphnodes whose update blocks are in the range of the entry point`
`1231`		`- bool inStartRange = graphNode.updateBlock.startpc >= entrypoint;`
`1232`		`- if (graphNode.isDirty && inStartRange)`
	`1230`	`+ if (graphNode.isDirty)`
`1233`	`1231`	`{`
`1234`	`1232`	`pc = graphNode.updateBlock.startpc;`
`1235`	`1233`	`graphNode.isDirty = false;`