[DNM] Optimize live execution of modified graphs (#9485)

aparajit-pratap · saintentropy · web-flow · commit dac83537a5a5 · 2022-04-26T16:57:43.000-04:00
* optimization of execution of modified graphs

* fix live execution tests for modified inputs

* code cleanup

* code fix

* code fixes

* mark added subtrees as input subtrees

* Fix incorrect merge conflict flix

* Changes to fix build

* Run second exection via ApplyUpdate similar to previous run model

* add support for string input

* Ignore unsupported inputs (dropdown, datetime, etc)

* update for case with modified UI node

Co-authored-by: Craig Long &lt;craig.long@autodesk.com&gt;
Co-authored-by: Craig Long &lt;craig.alan.long@gmail.com&gt;
diff --git a/src/DynamoCore/Engine/EngineController.cs b/src/DynamoCore/Engine/EngineController.cs
@@ -428,6 +428,23 @@ private bool VerifyGraphSyncData(IEnumerable<NodeModel> nodes)
                 }
             }
 
+            var subtrees = new List<Subtree>();
+            subtrees.AddRange(graphSyncdata.AddedSubtrees);
+            subtrees.AddRange(graphSyncdata.ModifiedSubtrees);
+            foreach (var node in nodes)
+            {
+                if (node.IsInputNode)
+                {
+                    for (int i = 0; i < subtrees.Count; i++)
+                    {
+                        if (subtrees[i].GUID == node.GUID)
+                        {
+                            subtrees[i].IsInput = true;
+                        }
+                    }
+                }
+            }
+
             if (graphSyncdata.AddedSubtrees.Any() || graphSyncdata.ModifiedSubtrees.Any() || graphSyncdata.DeletedSubtrees.Any())
             {
                 lock (graphSyncDataQueue)
diff --git a/src/Engine/ProtoAssociative/CodeGen.cs b/src/Engine/ProtoAssociative/CodeGen.cs
@@ -5420,6 +5420,18 @@ private void EmitBinaryExpressionNode(AssociativeNode node, ref ProtoCore.Type i
                             EmitCast(castType.UID, castType.rank);
                         }
 
+                        if (bnode.IsInputExpression)
+                        {
+                            StackValue regLX = StackValue.BuildRegister(Registers.LX);
+                            EmitInstrConsole(ProtoCore.DSASM.kw.pop, ProtoCore.DSASM.kw.regLX);
+                            EmitPop(regLX, globalClassIndex);
+
+                            graphNode.updateBlock.updateRegisterStartPC = pc;
+
+                            EmitInstrConsole(ProtoCore.DSASM.kw.push, ProtoCore.DSASM.kw.regLX);
+                            EmitPush(regLX);
+                        }
+
                         if (core.Options.RunMode != ProtoCore.DSASM.InterpreterMode.Expression)
                         {
                             if (dimensions == 0)
diff --git a/src/Engine/ProtoAssociative/CodeGen_SSA.cs b/src/Engine/ProtoAssociative/CodeGen_SSA.cs
@@ -488,6 +488,7 @@ private void DFSEmitSSA_AST(AssociativeNode node, Stack<AssociativeNode> ssaStac
 
                 var bnode = AstFactory.BuildAssignment(leftNode, rightNode);
                 bnode.isSSAAssignment = isSSAAssignment;
+                bnode.IsInputExpression = astBNode.IsInputExpression;
 
                 astlist.Add(bnode);
                 ssaStack.Push(bnode);
diff --git a/src/Engine/ProtoCore/AssociativeGraph.cs b/src/Engine/ProtoCore/AssociativeGraph.cs
@@ -746,8 +746,8 @@ public static ProtoCore.AssociativeGraph.GraphNode GetFirstSSAGraphnode(int inde
         /// <param name="core"></param>
         /// <param name="nodeList"></param>
         /// <returns></returns>
-        public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope
-(RuntimeCore core, IEnumerable<AST.AssociativeAST.AssociativeNode> nodeList)
+        public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope(
+            RuntimeCore core, IEnumerable<AST.AssociativeAST.AssociativeNode> nodeList)
         {
             if (nodeList == null)
             {
@@ -767,9 +767,7 @@ public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope
                 {
                     if (gnode.isActive && gnode.OriginalAstID == bNode.OriginalAstID)
                     {
-                        
                         gnode.isDirty = true;
-                        gnode.isActive = true;
                         if (gnode.updateBlock.updateRegisterStartPC != Constants.kInvalidIndex)
                         {
                             gnode.updateBlock.startpc = gnode.updateBlock.updateRegisterStartPC;
diff --git a/src/Engine/ProtoCore/DSASM/Executive.cs b/src/Engine/ProtoCore/DSASM/Executive.cs
@@ -36,6 +36,7 @@ public RuntimeCore RuntimeCore
         private InstructionStream istream;
         public RuntimeMemory rmem { get; set; }
 
+        private StackValue LX;
         public StackValue RX { get; set; }
         public StackValue TX { get; set; }
 
@@ -66,7 +67,12 @@ enum DebugFlags
         /// This is updated for every bounce and function call
         /// </summary>
         private List<AssociativeGraph.GraphNode> graphNodesInProgramScope;
-        
+
+        public void SetAssociativeUpdateRegister(StackValue sv)
+        {
+            LX = sv;
+        }
+
         public Executive(RuntimeCore runtimeCore, bool isFep = false)
         {
             IsExplicitCall = false;
@@ -1341,8 +1347,12 @@ private int UpdateGraph(int exprUID, bool isSSAAssign)
 
             // Mark reachable nodes as dirty
             Validity.Assert(reachableGraphNodes != null);
+            //int nextPC;
             if (reachableGraphNodes.Count > 0)
             {
+                // Get the next pc to jump to
+                //nextPC = reachableGraphNodes[0].updateBlock.startpc;
+                //LX = StackValue.BuildInt(nextPC);
                 for (int n = 0; n < reachableGraphNodes.Count; ++n)
                 {
                     AssociativeGraph.GraphNode gnode = reachableGraphNodes[n];
@@ -1636,6 +1646,7 @@ private void ResumeRegistersFromStack()
             int fp = rmem.FramePointer;
             if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)
             {
+                LX = rmem.GetAtRelative(StackFrame.FrameIndexLX);
                 RX = rmem.GetAtRelative(StackFrame.FrameIndexRX);
                 TX = rmem.GetAtRelative(StackFrame.FrameIndexTX);
             }
@@ -1646,6 +1657,7 @@ private void ResumeRegistersFromStackExceptRX()
             int fp = rmem.FramePointer;
             if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)
             {
+                LX = rmem.GetAtRelative(StackFrame.FrameIndexLX);
                 TX = rmem.GetAtRelative(StackFrame.FrameIndexTX);
             }
        }
@@ -1655,14 +1667,15 @@ private void SaveRegistersToStack()
             int fp = rmem.FramePointer;
             if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)
             {
+                rmem.SetAtRelative(StackFrame.FrameIndexLX, LX);
                 rmem.SetAtRelative(StackFrame.FrameIndexRX, RX);
                 rmem.SetAtRelative(StackFrame.FrameIndexTX, TX);
             }
         }
 
         public List<StackValue> GetRegisters()
         {
-            return new List<StackValue> { RX, TX };
+            return new List<StackValue> { RX, TX, LX };
         }
 
         /// <summary>
@@ -2339,6 +2352,9 @@ private StackValue GetOperandData(int blockId, StackValue opSymbol, StackValue o
                 case AddressType.Register:
                     switch (opSymbol.Register)
                     {
+                        case Registers.LX:
+                            data = LX;
+                            break;
                         case Registers.RX:
                             data = RX;
                             break;
@@ -2452,6 +2468,10 @@ protected StackValue PopTo(int blockId, StackValue op1, StackValue op2, StackVal
                         StackValue data = opVal;
                         switch (op1.Register)
                         {
+                            case Registers.LX:
+                                opPrev = LX;
+                                LX = data;
+                                break;
                             case Registers.RX:
                                 opPrev = RX;
                                 RX = data;
diff --git a/src/Engine/ProtoCore/DSASM/InstructionSet.cs b/src/Engine/ProtoCore/DSASM/InstructionSet.cs
@@ -10,6 +10,7 @@ namespace ProtoCore.DSASM
     public enum Registers
     {
         RX,
+        LX,
     }
 
     public enum AddressType: int 
diff --git a/src/Engine/ProtoCore/DSASM/Stack.cs b/src/Engine/ProtoCore/DSASM/Stack.cs
@@ -33,8 +33,9 @@ public class StackFrame
         public const int FrameIndexBlockIndex = -12;
         public const int FrameIndexRX = -13;
         public const int FrameIndexTX = -14;
-        public const int FrameIndexFramePointer = -15;
-        public const int StackFrameSize = 15;
+        public const int FrameIndexLX = -15;
+        public const int FrameIndexFramePointer = -16;
+        public const int StackFrameSize = 16;
 
         private struct AbsoluteIndex
         {
@@ -52,6 +53,7 @@ private struct AbsoluteIndex
             public const int BlockIndex = -FrameIndexBlockIndex - 1;
             public const int RX = -FrameIndexRX - 1;
             public const int TX = -FrameIndexTX - 1;
+            public const int LX = -FrameIndexLX - 1;
             public const int FramePointer = -FrameIndexFramePointer - 1;
         }
 
@@ -89,6 +91,7 @@ private void Init(
             Frame[AbsoluteIndex.BlockIndex] = StackValue.BuildBlockIndex(blockIndex);
             Frame[AbsoluteIndex.RX] = registers[0];
             Frame[AbsoluteIndex.TX] = registers[1];
+            Frame[AbsoluteIndex.LX] = registers[2];
             Frame[AbsoluteIndex.FramePointer] = StackValue.BuildInt(framePointer);
         }
 
@@ -217,12 +220,19 @@ public StackValue TX
             set { Frame[AbsoluteIndex.TX] = value; }
         }
 
+        public StackValue LX
+        {
+            get { return Frame[AbsoluteIndex.LX]; }
+            set { Frame[AbsoluteIndex.LX] = value; }
+        }
+
         public List<StackValue> GetRegisters()
         {
             List<StackValue> registers = new List<StackValue>();
 
             registers.Add(Frame[AbsoluteIndex.RX]);
             registers.Add(Frame[AbsoluteIndex.TX]);
+            registers.Add(Frame[AbsoluteIndex.LX]);
 
             return registers;
         }
diff --git a/src/Engine/ProtoCore/Lang/FunctionPointerEvaluator.cs b/src/Engine/ProtoCore/Lang/FunctionPointerEvaluator.cs
@@ -107,7 +107,6 @@ public StackValue Evaluate(List<StackValue> args, StackFrame stackFrame)
             interpreter.runtime.TX = StackValue.BuildCallingConversion((int)ProtoCore.DSASM.CallingConvention.BounceType.Implicit);
 
             StackValue svBlockDecl = StackValue.BuildBlockIndex(blockDecl);
-            // interpreter.runtime.SX = svBlockDecl;
 
             List<StackValue> registers = interpreter.runtime.GetRegisters();
             var newStackFrame = new StackFrame(thisPtr, 
diff --git a/src/Engine/ProtoCore/Parser/AssociativeAST.cs b/src/Engine/ProtoCore/Parser/AssociativeAST.cs
@@ -2082,6 +2082,7 @@ public class BinaryExpressionNode : AssociativeNode
         public AssociativeNode LeftNode { get; set; }
         public Operator Optr { get; set; }
         public AssociativeNode RightNode { get; set; }
+        public bool IsInputExpression { get; set; }
         public bool isSSAPointerAssignment { get; set; }
         public bool IsFirstIdentListNode { get; set; }
 
@@ -2097,6 +2098,7 @@ public BinaryExpressionNode(AssociativeNode left = null, AssociativeNode right =
             LeftNode = left;
             Optr = optr;
             RightNode = right;
+            IsInputExpression = false;
             IsFirstIdentListNode = false;
         }
 
@@ -2117,6 +2119,7 @@ public BinaryExpressionNode(BinaryExpressionNode rhs) : base(rhs)
             {
                 RightNode = NodeUtils.Clone(rhs.RightNode);
             }
+            IsInputExpression = rhs.IsInputExpression;
             IsFirstIdentListNode = rhs.IsFirstIdentListNode;
         }
 
@@ -2140,7 +2143,8 @@ public BinaryExpressionNode(IdentifierNode lhs, AssociativeNode rhs)
              Optr = Operator.assign;
              LeftNode = lhs;
              RightNode = NodeUtils.Clone(rhs);
-             IsFirstIdentListNode = false;
+             IsInputExpression = false;
+            IsFirstIdentListNode = false;
              
          }
 
diff --git a/src/Engine/ProtoCore/RuntimeCore.cs b/src/Engine/ProtoCore/RuntimeCore.cs
@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Linq;
 using ProtoCore.AssociativeGraph;
+using ProtoCore.AST.AssociativeAST;
 using ProtoCore.DSASM;
 using ProtoCore.Lang;
 using ProtoCore.Lang.Replication;
@@ -333,6 +334,21 @@ public TimeSpan GetCurrentTime()
             return ts;
         }
 
+        /// <summary>
+        /// Set the value of a variable at runtime
+        /// Returns the entry pc
+        /// </summary>
+        /// <param name="astID"></param>
+        /// <param name="sv"></param>
+        /// <returns></returns>
+        public int SetValue(List<AssociativeNode> modifiedNodes, StackValue sv)
+        {
+            ExecutionInstance.CurrentDSASMExec.SetAssociativeUpdateRegister(sv);
+            GraphNode gnode = AssociativeEngine.Utils.MarkGraphNodesDirtyAtGlobalScope(this, modifiedNodes);
+            Validity.Assert(gnode != null);
+            return gnode.updateBlock.startpc;
+        }
+
         /// <summary>
         /// This function determines what the starting pc should be for the next execution session
         /// The StartPC takes precedence if set. Otherwise, the entry pc in the global codeblock is the entry point
diff --git a/src/Engine/ProtoCore/Utils/CoreUtils.cs b/src/Engine/ProtoCore/Utils/CoreUtils.cs
@@ -952,5 +952,50 @@ public static StackValue AddStackValueString(StackValue sv1, StackValue sv2, Run
             }
             return StackValue.BuildNull();
         }
+
+        /// <summary>
+        /// Checks if an AST node is a primitive
+        /// </summary>
+        /// <param name="node"></param>
+        /// <returns></returns>
+        public static bool IsPrimitiveASTNode(AssociativeNode node)
+        {
+            if (node is IntNode
+                || node is DoubleNode
+                || node is BooleanNode
+                || node is StringNode)
+            {
+                return true;
+            }
+            return false;
+        }
+
+
+        public static StackValue BuildStackValueForPrimitive(AssociativeNode node, RuntimeCore rt)
+        {
+            Validity.Assert(IsPrimitiveASTNode(node) == true);
+
+            if (node is IntNode)
+            {
+                return StackValue.BuildInt((node as IntNode).Value);
+            }
+
+            if (node is DoubleNode)
+            {
+                return StackValue.BuildDouble((node as DoubleNode).Value);
+            }
+
+            if (node is BooleanNode)
+            {
+                return StackValue.BuildBoolean((node as BooleanNode).Value);
+            }
+
+            if (node is StringNode)
+            {
+                return StackValue.BuildString((node as StringNode).Value, rt.Heap);
+            }
+
+            return StackValue.BuildNull();
+        }
     }
 }
diff --git a/src/Engine/ProtoScript/Runners/LiveRunner.cs b/src/Engine/ProtoScript/Runners/LiveRunner.cs
diff --git a/test/Engine/ProtoTest/LiveRunnerTests/MemoryConsumptionTests.cs b/test/Engine/ProtoTest/LiveRunnerTests/MemoryConsumptionTests.cs

Original file line number	Diff line number	Diff line change
`@@ -746,8 +746,8 @@ public static ProtoCore.AssociativeGraph.GraphNode GetFirstSSAGraphnode(int inde`
`746`	`746`	`/// <param name="core"></param>`
`747`	`747`	`/// <param name="nodeList"></param>`
`748`	`748`	`/// <returns></returns>`
`749`		`- public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope`
`750`		`-(RuntimeCore core, IEnumerable<AST.AssociativeAST.AssociativeNode> nodeList)`
	`749`	`+ public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope(`
	`750`	`+ RuntimeCore core, IEnumerable<AST.AssociativeAST.AssociativeNode> nodeList)`
`751`	`751`	`{`
`752`	`752`	`if (nodeList == null)`
`753`	`753`	`{`
`@@ -767,9 +767,7 @@ public static AssociativeGraph.GraphNode MarkGraphNodesDirtyAtGlobalScope`
`767`	`767`	`{`
`768`	`768`	`if (gnode.isActive && gnode.OriginalAstID == bNode.OriginalAstID)`
`769`	`769`	`{`
`770`		`-`
`771`	`770`	`gnode.isDirty = true;`
`772`		`- gnode.isActive = true;`
`773`	`771`	`if (gnode.updateBlock.updateRegisterStartPC != Constants.kInvalidIndex)`
`774`	`772`	`{`
`775`	`773`	`gnode.updateBlock.startpc = gnode.updateBlock.updateRegisterStartPC;`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ public RuntimeCore RuntimeCore`
`36`	`36`	`private InstructionStream istream;`
`37`	`37`	`public RuntimeMemory rmem { get; set; }`
`38`	`38`
	`39`	`+ private StackValue LX;`
`39`	`40`	`public StackValue RX { get; set; }`
`40`	`41`	`public StackValue TX { get; set; }`
`41`	`42`
`@@ -66,7 +67,12 @@ enum DebugFlags`
`66`	`67`	`/// This is updated for every bounce and function call`
`67`	`68`	`/// </summary>`
`68`	`69`	`private List<AssociativeGraph.GraphNode> graphNodesInProgramScope;`
`69`		`-`
	`70`	`+`
	`71`	`+ public void SetAssociativeUpdateRegister(StackValue sv)`
	`72`	`+ {`
	`73`	`+ LX = sv;`
	`74`	`+ }`
	`75`	`+`
`70`	`76`	`public Executive(RuntimeCore runtimeCore, bool isFep = false)`
`71`	`77`	`{`
`72`	`78`	`IsExplicitCall = false;`
`@@ -1341,8 +1347,12 @@ private int UpdateGraph(int exprUID, bool isSSAAssign)`
`1341`	`1347`
`1342`	`1348`	`// Mark reachable nodes as dirty`
`1343`	`1349`	`Validity.Assert(reachableGraphNodes != null);`
	`1350`	`+ //int nextPC;`
`1344`	`1351`	`if (reachableGraphNodes.Count > 0)`
`1345`	`1352`	`{`
	`1353`	`+ // Get the next pc to jump to`
	`1354`	`+ //nextPC = reachableGraphNodes[0].updateBlock.startpc;`
	`1355`	`+ //LX = StackValue.BuildInt(nextPC);`
`1346`	`1356`	`for (int n = 0; n < reachableGraphNodes.Count; ++n)`
`1347`	`1357`	`{`
`1348`	`1358`	`AssociativeGraph.GraphNode gnode = reachableGraphNodes[n];`
`@@ -1636,6 +1646,7 @@ private void ResumeRegistersFromStack()`
`1636`	`1646`	`int fp = rmem.FramePointer;`
`1637`	`1647`	`if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)`
`1638`	`1648`	`{`
	`1649`	`+ LX = rmem.GetAtRelative(StackFrame.FrameIndexLX);`
`1639`	`1650`	`RX = rmem.GetAtRelative(StackFrame.FrameIndexRX);`
`1640`	`1651`	`TX = rmem.GetAtRelative(StackFrame.FrameIndexTX);`
`1641`	`1652`	`}`
`@@ -1646,6 +1657,7 @@ private void ResumeRegistersFromStackExceptRX()`
`1646`	`1657`	`int fp = rmem.FramePointer;`
`1647`	`1658`	`if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)`
`1648`	`1659`	`{`
	`1660`	`+ LX = rmem.GetAtRelative(StackFrame.FrameIndexLX);`
`1649`	`1661`	`TX = rmem.GetAtRelative(StackFrame.FrameIndexTX);`
`1650`	`1662`	`}`
`1651`	`1663`	`}`
`@@ -1655,14 +1667,15 @@ private void SaveRegistersToStack()`
`1655`	`1667`	`int fp = rmem.FramePointer;`
`1656`	`1668`	`if (fp >= rmem.GlobOffset + StackFrame.StackFrameSize)`
`1657`	`1669`	`{`
	`1670`	`+ rmem.SetAtRelative(StackFrame.FrameIndexLX, LX);`
`1658`	`1671`	`rmem.SetAtRelative(StackFrame.FrameIndexRX, RX);`
`1659`	`1672`	`rmem.SetAtRelative(StackFrame.FrameIndexTX, TX);`
`1660`	`1673`	`}`
`1661`	`1674`	`}`
`1662`	`1675`
`1663`	`1676`	`public List<StackValue> GetRegisters()`
`1664`	`1677`	`{`
`1665`		`- return new List<StackValue> { RX, TX };`
	`1678`	`+ return new List<StackValue> { RX, TX, LX };`
`1666`	`1679`	`}`
`1667`	`1680`
`1668`	`1681`	`/// <summary>`
`@@ -2339,6 +2352,9 @@ private StackValue GetOperandData(int blockId, StackValue opSymbol, StackValue o`
`2339`	`2352`	`case AddressType.Register:`
`2340`	`2353`	`switch (opSymbol.Register)`
`2341`	`2354`	`{`
	`2355`	`+ case Registers.LX:`
	`2356`	`+ data = LX;`
	`2357`	`+ break;`
`2342`	`2358`	`case Registers.RX:`
`2343`	`2359`	`data = RX;`
`2344`	`2360`	`break;`
`@@ -2452,6 +2468,10 @@ protected StackValue PopTo(int blockId, StackValue op1, StackValue op2, StackVal`
`2452`	`2468`	`StackValue data = opVal;`
`2453`	`2469`	`switch (op1.Register)`
`2454`	`2470`	`{`
	`2471`	`+ case Registers.LX:`
	`2472`	`+ opPrev = LX;`
	`2473`	`+ LX = data;`
	`2474`	`+ break;`
`2455`	`2475`	`case Registers.RX:`
`2456`	`2476`	`opPrev = RX;`
`2457`	`2477`	`RX = data;`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace ProtoCore.DSASM`
`10`	`10`	`public enum Registers`
`11`	`11`	`{`
`12`	`12`	`RX,`
	`13`	`+ LX,`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`public enum AddressType: int`
Original file line number	Diff line number	Diff line change
`@@ -2082,6 +2082,7 @@ public class BinaryExpressionNode : AssociativeNode`
`2082`	`2082`	`public AssociativeNode LeftNode { get; set; }`
`2083`	`2083`	`public Operator Optr { get; set; }`
`2084`	`2084`	`public AssociativeNode RightNode { get; set; }`
	`2085`	`+ public bool IsInputExpression { get; set; }`
`2085`	`2086`	`public bool isSSAPointerAssignment { get; set; }`
`2086`	`2087`	`public bool IsFirstIdentListNode { get; set; }`
`2087`	`2088`
`@@ -2097,6 +2098,7 @@ public BinaryExpressionNode(AssociativeNode left = null, AssociativeNode right =`
`2097`	`2098`	`LeftNode = left;`
`2098`	`2099`	`Optr = optr;`
`2099`	`2100`	`RightNode = right;`
	`2101`	`+ IsInputExpression = false;`
`2100`	`2102`	`IsFirstIdentListNode = false;`
`2101`	`2103`	`}`
`2102`	`2104`
`@@ -2117,6 +2119,7 @@ public BinaryExpressionNode(BinaryExpressionNode rhs) : base(rhs)`
`2117`	`2119`	`{`
`2118`	`2120`	`RightNode = NodeUtils.Clone(rhs.RightNode);`
`2119`	`2121`	`}`
	`2122`	`+ IsInputExpression = rhs.IsInputExpression;`
`2120`	`2123`	`IsFirstIdentListNode = rhs.IsFirstIdentListNode;`
`2121`	`2124`	`}`
`2122`	`2125`
`@@ -2140,7 +2143,8 @@ public BinaryExpressionNode(IdentifierNode lhs, AssociativeNode rhs)`
`2140`	`2143`	`Optr = Operator.assign;`
`2141`	`2144`	`LeftNode = lhs;`
`2142`	`2145`	`RightNode = NodeUtils.Clone(rhs);`
`2143`		`- IsFirstIdentListNode = false;`
	`2146`	`+ IsInputExpression = false;`
	`2147`	`+ IsFirstIdentListNode = false;`
`2144`	`2148`
`2145`	`2149`	`}`
`2146`	`2150`