DynamoDS
diff --git a/‎src/Engine/ProtoCore/CodeGen.cs
Copy file name to clipboard
+59-31Lines changed: 59 additions & 31 deletions b/‎src/Engine/ProtoCore/CodeGen.cs
Copy file name to clipboard
+59-31Lines changed: 59 additions & 31 deletions
diff --git a/‎src/Engine/ProtoCore/Utils/CoreUtils.cs
Copy file name to clipboard
+92-1Lines changed: 92 additions & 1 deletion b/‎src/Engine/ProtoCore/Utils/CoreUtils.cs
Copy file name to clipboard
+92-1Lines changed: 92 additions & 1 deletion
@@ -627,44 +627,70 @@ protected bool DfsEmitIdentList(
             Node binaryExpNode = null)
         {
             dynamic node = pNode;
-            if (node is ProtoCore.AST.ImperativeAST.IdentifierListNode || node is ProtoCore.AST.AssociativeAST.IdentifierListNode)
+            if (node is AST.ImperativeAST.IdentifierListNode || node is AST.AssociativeAST.IdentifierListNode)
             {
                 dynamic bnode = node;
-                if (ProtoCore.DSASM.Operator.dot != bnode.Optr)
+                if (Operator.dot != bnode.Optr)
                 {
                     string message = "The left hand side of an operation can only contain an indirection operator '.' (48D67B9B)";
                     buildStatus.LogSemanticError(message, core.CurrentDSFileName, bnode.line, bnode.col);
                     throw new BuildHaltException(message);
                 }
 
-                DfsEmitIdentList(bnode.LeftNode, bnode, contextClassScope, ref lefttype, ref depth, ref finalType, isLeftidentList, graphNode, subPass);
+                var identListNode = bnode.LeftNode as AST.ImperativeAST.IdentifierListNode;
+                int ci = Constants.kInvalidIndex;
+                bool isImperativeFunc = true;
 
-                if (lefttype.rank > 0)
+                if (identListNode != null)
                 {
-                    lefttype.UID = finalType.UID = (int)PrimitiveType.Null;
-                    EmitPushNull();
-                    return false;
+                    // Check if identListNode is a valid class 
+                    // A valid class exists for the following cases of identListNode:
+                    // A.B.ClassName
+                    // A valid class is not found for the following, in which case, continue recursing into LeftNode:
+                    // A.B.ClassName.foo() where identListNode.RightNode is the function foo()
+                    // A.B.ClassName.Property
+                    isImperativeFunc = identListNode.RightNode is AST.ImperativeAST.FunctionCallNode;
+                    if(!isImperativeFunc)
+                    {
+                        var className = CoreUtils.GetIdentifierStringUntilFirstParenthesis(identListNode);
+                        ci = core.ClassTable.IndexOf(className);
+                    }
+                    if (ci != Constants.kInvalidIndex && !isImperativeFunc)
+                    {
+                        finalType.UID = lefttype.UID = ci;
+                    }
+                }
+                if (ci == Constants.kInvalidIndex || isImperativeFunc)
+                {
+                    DfsEmitIdentList(bnode.LeftNode, bnode, contextClassScope, ref lefttype, ref depth, ref finalType, isLeftidentList, graphNode, subPass);
+
+                    if (lefttype.rank > 0)
+                    {
+                        lefttype.UID = finalType.UID = (int)PrimitiveType.Null;
+                        EmitPushNull();
+                        return false;
+                    }
                 }
                 node = bnode.RightNode;
             }
 
-            if (node is ProtoCore.AST.ImperativeAST.GroupExpressionNode)
+            if (node is AST.ImperativeAST.GroupExpressionNode)
             {
-                ProtoCore.AST.ImperativeAST.ArrayNode array = node.ArrayDimensions;
+                var array = node.ArrayDimensions;
                 node = node.Expression;
                 node.ArrayDimensions = array;
             }
-            else if (node is ProtoCore.AST.AssociativeAST.GroupExpressionNode)
+            else if (node is AST.AssociativeAST.GroupExpressionNode)
             {
-                ProtoCore.AST.AssociativeAST.ArrayNode array = node.ArrayDimensions;
-                List<ProtoCore.AST.AssociativeAST.AssociativeNode> replicationGuides = node.ReplicationGuides;
+                var array = node.ArrayDimensions;
+                var replicationGuides = node.ReplicationGuides;
 
                 node = node.Expression;
                 node.ArrayDimensions = array;
                 node.ReplicationGuides = replicationGuides;
             }
 
-            if (node is ProtoCore.AST.ImperativeAST.IdentifierNode || node is ProtoCore.AST.AssociativeAST.IdentifierNode)
+            if (node is AST.ImperativeAST.IdentifierNode || node is AST.AssociativeAST.IdentifierNode)
             {
                 dynamic identnode = node;
 
@@ -723,7 +749,7 @@ protected bool DfsEmitIdentList(
                         }
                         else
                         {
-                            DSASM.DyanmicVariableNode dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Value, globalProcIndex, globalClassIndex);
+                            var dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Value, globalProcIndex, globalClassIndex);
                             core.DynamicVariableTable.variableTable.Add(dynamicVariableNode);
                             int dim = 0;
                             if (null != identnode.ArrayDimensions)
@@ -772,8 +798,8 @@ protected bool DfsEmitIdentList(
                     StackValue op = StackValue.Null;
                     if (0 == depth || (symbolnode != null && symbolnode.isStatic))
                     {
-                        if (ProtoCore.DSASM.Constants.kGlobalScope == symbolnode.functionIndex
-                            && ProtoCore.DSASM.Constants.kInvalidIndex != symbolnode.classScope)
+                        if (Constants.kGlobalScope == symbolnode.functionIndex
+                            && Constants.kInvalidIndex != symbolnode.classScope)
                         {
                             // member var
                             if (symbolnode.isStatic)
@@ -806,7 +832,7 @@ protected bool DfsEmitIdentList(
                     else
                     {
                         // change to dynamic call to facilitate update mechanism
-                        DSASM.DyanmicVariableNode dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Name, globalProcIndex, globalClassIndex);
+                        var dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Name, globalProcIndex, globalClassIndex);
                         core.DynamicVariableTable.variableTable.Add(dynamicVariableNode);
                         StackValue dynamicOp = StackValue.BuildDynamic(core.DynamicVariableTable.variableTable.Count - 1);
                         EmitInstrConsole(ProtoCore.DSASM.kw.pushm, identnode.Value + "[dynamic]");
@@ -828,7 +854,7 @@ protected bool DfsEmitIdentList(
                 }
                 return true;
             }
-            else if (node is ProtoCore.AST.ImperativeAST.FunctionCallNode || node is ProtoCore.AST.AssociativeAST.FunctionCallNode)
+            else if (node is AST.ImperativeAST.FunctionCallNode || node is AST.AssociativeAST.FunctionCallNode)
             {
                 // A function call must always track dependents
                 bool allowDependents = true;
@@ -842,7 +868,7 @@ protected bool DfsEmitIdentList(
                 {
                     ProtoCore.Utils.NodeUtils.SetNodeLocation(node, binaryExpNode, binaryExpNode);
                 }
-                ProtoCore.DSASM.ProcedureNode procnode = TraverseFunctionCall(node, pNode, lefttype.UID, depth, ref finalType, graphNode, subPass, binaryExpNode);
+                var procnode = TraverseFunctionCall(node, pNode, lefttype.UID, depth, ref finalType, graphNode, subPass, binaryExpNode);
 
                 // Restore the graphNode dependent state
                 if (null != graphNode)
@@ -2033,24 +2059,26 @@ protected void BuildRealDependencyForIdentList(AssociativeGraph.GraphNode graphN
             }
         }
 
-        protected void EmitIdentifierListNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false, 
-            ProtoCore.AssociativeGraph.GraphNode graphNode = null, 
-            ProtoCore.CompilerDefinitions.SubCompilePass subPass = ProtoCore.CompilerDefinitions.SubCompilePass.None, 
-            ProtoCore.AST.Node bnode = null)
+        protected void EmitIdentifierListNode(Node node, 
+            ref Type inferedType, 
+            bool isBooleanOp = false,
+            AssociativeGraph.GraphNode graphNode = null,
+            CompilerDefinitions.SubCompilePass subPass = CompilerDefinitions.SubCompilePass.None,
+            Node bnode = null)
         {
-            if (subPass == ProtoCore.CompilerDefinitions.SubCompilePass.UnboundIdentifier)
+            if (subPass == CompilerDefinitions.SubCompilePass.UnboundIdentifier)
             {
                 //to process all unbounded parameters if any
                 dynamic iNode = node;
-                while (iNode is ProtoCore.AST.AssociativeAST.IdentifierListNode || iNode is ProtoCore.AST.ImperativeAST.IdentifierListNode)
+                while (iNode is AST.AssociativeAST.IdentifierListNode || iNode is AST.ImperativeAST.IdentifierListNode)
                 {
                     dynamic rightNode = iNode.RightNode;
-                    if (rightNode is ProtoCore.AST.AssociativeAST.FunctionCallNode || rightNode is ProtoCore.AST.ImperativeAST.FunctionCallNode)
+                    if (rightNode is AST.AssociativeAST.FunctionCallNode || rightNode is AST.ImperativeAST.FunctionCallNode)
                     {
                         foreach (dynamic paramNode in rightNode.FormalArguments)
                         {
-                            ProtoCore.Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);
-                            DfsTraverse(paramNode, ref paramType, false, graphNode, ProtoCore.CompilerDefinitions.SubCompilePass.UnboundIdentifier);
+                            Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);
+                            DfsTraverse(paramNode, ref paramType, false, graphNode, CompilerDefinitions.SubCompilePass.UnboundIdentifier);
                         }
                     }
                     iNode = iNode.LeftNode;
@@ -2060,16 +2088,16 @@ protected void EmitIdentifierListNode(Node node, ref ProtoCore.Type inferedType,
 
             int depth = 0;
 
-            ProtoCore.Type leftType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.InvalidType, 0);
+            Type leftType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.InvalidType, 0);
 
             BuildSSADependency(node, graphNode);
             if (core.Options.GenerateSSA)
             {
                 BuildRealDependencyForIdentList(graphNode);
 
-                if (node is ProtoCore.AST.AssociativeAST.IdentifierListNode)
+                if (node is AST.AssociativeAST.IdentifierListNode)
                 {
-                    if ((node as ProtoCore.AST.AssociativeAST.IdentifierListNode).IsLastSSAIdentListFactor)
+                    if ((node as AST.AssociativeAST.IdentifierListNode).IsLastSSAIdentListFactor)
                     {
                         Validity.Assert(null != ssaPointerStack);
                         ssaPointerStack.Pop();
 
@@ -478,8 +478,13 @@ public static int GetFunctionHash(FunctionDefinitionNode functionDef)
         /// </summary>
         /// <param name="identList"></param>
         /// <returns></returns>
-        public static string GetIdentifierStringUntilFirstParenthesis(IdentifierListNode identList)
+        public static string GetIdentifierStringUntilFirstParenthesis(AST.Node node)
         {
+            dynamic identList = node as IdentifierListNode;
+            if(identList == null)
+            {
+                identList = node as AST.ImperativeAST.IdentifierListNode;
+            }
             Validity.Assert(null != identList);
             string identListString = identList.ToString();
             int removeIndex = identListString.IndexOf('(');
@@ -544,6 +549,60 @@ public static string GetIdentifierExceptMethodName(IdentifierListNode identList)
             return CreateNodeByCombiningIdentifiers(intermediateNodes).ToString();
         }
 
+        /// <summary>
+        /// Retrieves the string format of the identifier list from left to right, leaving out any symbols after the last identifier.
+        /// Given: A.B()
+        ///     Return: "A"
+        /// Given: A.B.C()[0]
+        ///     Return: "A.B"
+        /// Given: A.B().C
+        ///     Return: "A"
+        /// Given: A.B[0].C
+        ///     Return: "A.B[0].C"
+        /// Given: A().B (global function)
+        ///     Return: empty string
+        /// Given: A.B[0].C()
+        ///     Return: "A.B[0]"
+        /// </summary>
+        /// <param name="identList"></param>
+        /// <returns></returns>
+        public static string GetIdentifierExceptMethodName(AST.ImperativeAST.IdentifierListNode identList)
+        {
+            Validity.Assert(null != identList);
+
+            var leftNode = identList.LeftNode;
+            var rightNode = identList.RightNode;
+
+            var intermediateNodes = new List<AST.ImperativeAST.ImperativeNode>();
+            if (!(rightNode is AST.ImperativeAST.FunctionCallNode))
+            {
+                intermediateNodes.Insert(0, rightNode);
+            }
+
+            while (leftNode is AST.ImperativeAST.IdentifierListNode)
+            {
+                rightNode = ((AST.ImperativeAST.IdentifierListNode)leftNode).RightNode;
+                if (rightNode is AST.ImperativeAST.FunctionCallNode)
+                {
+                    intermediateNodes.Clear();
+                }
+                else
+                {
+                    intermediateNodes.Insert(0, rightNode);
+                }
+                leftNode = ((AST.ImperativeAST.IdentifierListNode)leftNode).LeftNode;
+
+            }
+            if (leftNode is AST.ImperativeAST.FunctionCallNode)
+            {
+                intermediateNodes.Clear();
+                return "";
+            }
+            intermediateNodes.Insert(0, leftNode);
+
+            return CreateNodeByCombiningIdentifiers(intermediateNodes).ToString();
+        }
+
         /// <summary>
         /// Inspects the input identifier list to match all class names with the class used in it
         /// </summary>
@@ -670,6 +729,38 @@ public static AssociativeNode CreateNodeByCombiningIdentifiers(IList<Associative
             return newIdentList;
         }
 
+        private static AST.ImperativeAST.ImperativeNode CreateNodeByCombiningIdentifiers(IList<AST.ImperativeAST.ImperativeNode> nodeList)
+        {
+            int count = nodeList.Count;
+            if (count == 0)
+                return null;
+
+            if (count == 1)
+            {
+                return nodeList[0];
+            }
+
+            var newIdentList = new AST.ImperativeAST.IdentifierListNode
+            {
+                LeftNode = nodeList[0],
+                RightNode = nodeList[1],
+                Optr = Operator.dot
+            };
+
+            for (var n = 2; n < count; ++n)
+            {
+                var subIdentList = new AST.ImperativeAST.IdentifierListNode
+                {
+                    LeftNode = newIdentList,
+                    RightNode = nodeList[n],
+                    Optr = Operator.dot
+                };
+                newIdentList = subIdentList;
+            }
+
+            return newIdentList;
+        }
+
         /// <summary>
         /// Parses designscript code and outputs ProtoAST
         /// </summary>
Original file line number	Diff line number	Diff line change
`@@ -627,44 +627,70 @@ protected bool DfsEmitIdentList(`
`627`	`627`	`Node binaryExpNode = null)`
`628`	`628`	`{`
`629`	`629`	`dynamic node = pNode;`
`630`		`- if (node is ProtoCore.AST.ImperativeAST.IdentifierListNode \|\| node is ProtoCore.AST.AssociativeAST.IdentifierListNode)`
	`630`	`+ if (node is AST.ImperativeAST.IdentifierListNode \|\| node is AST.AssociativeAST.IdentifierListNode)`
`631`	`631`	`{`
`632`	`632`	`dynamic bnode = node;`
`633`		`- if (ProtoCore.DSASM.Operator.dot != bnode.Optr)`
	`633`	`+ if (Operator.dot != bnode.Optr)`
`634`	`634`	`{`
`635`	`635`	`string message = "The left hand side of an operation can only contain an indirection operator '.' (48D67B9B)";`
`636`	`636`	`buildStatus.LogSemanticError(message, core.CurrentDSFileName, bnode.line, bnode.col);`
`637`	`637`	`throw new BuildHaltException(message);`
`638`	`638`	`}`
`639`	`639`
`640`		`- DfsEmitIdentList(bnode.LeftNode, bnode, contextClassScope, ref lefttype, ref depth, ref finalType, isLeftidentList, graphNode, subPass);`
	`640`	`+ var identListNode = bnode.LeftNode as AST.ImperativeAST.IdentifierListNode;`
	`641`	`+ int ci = Constants.kInvalidIndex;`
	`642`	`+ bool isImperativeFunc = true;`
`641`	`643`
`642`		`- if (lefttype.rank > 0)`
	`644`	`+ if (identListNode != null)`
`643`	`645`	`{`
`644`		`- lefttype.UID = finalType.UID = (int)PrimitiveType.Null;`
`645`		`- EmitPushNull();`
`646`		`- return false;`
	`646`	`+ // Check if identListNode is a valid class`
	`647`	`+ // A valid class exists for the following cases of identListNode:`
	`648`	`+ // A.B.ClassName`
	`649`	`+ // A valid class is not found for the following, in which case, continue recursing into LeftNode:`
	`650`	`+ // A.B.ClassName.foo() where identListNode.RightNode is the function foo()`
	`651`	`+ // A.B.ClassName.Property`
	`652`	`+ isImperativeFunc = identListNode.RightNode is AST.ImperativeAST.FunctionCallNode;`
	`653`	`+ if(!isImperativeFunc)`
	`654`	`+ {`
	`655`	`+ var className = CoreUtils.GetIdentifierStringUntilFirstParenthesis(identListNode);`
	`656`	`+ ci = core.ClassTable.IndexOf(className);`
	`657`	`+ }`
	`658`	`+ if (ci != Constants.kInvalidIndex && !isImperativeFunc)`
	`659`	`+ {`
	`660`	`+ finalType.UID = lefttype.UID = ci;`
	`661`	`+ }`
	`662`	`+ }`
	`663`	`+ if (ci == Constants.kInvalidIndex \|\| isImperativeFunc)`
	`664`	`+ {`
	`665`	`+ DfsEmitIdentList(bnode.LeftNode, bnode, contextClassScope, ref lefttype, ref depth, ref finalType, isLeftidentList, graphNode, subPass);`
	`666`	`+`
	`667`	`+ if (lefttype.rank > 0)`
	`668`	`+ {`
	`669`	`+ lefttype.UID = finalType.UID = (int)PrimitiveType.Null;`
	`670`	`+ EmitPushNull();`
	`671`	`+ return false;`
	`672`	`+ }`
`647`	`673`	`}`
`648`	`674`	`node = bnode.RightNode;`
`649`	`675`	`}`
`650`	`676`
`651`		`- if (node is ProtoCore.AST.ImperativeAST.GroupExpressionNode)`
	`677`	`+ if (node is AST.ImperativeAST.GroupExpressionNode)`
`652`	`678`	`{`
`653`		`- ProtoCore.AST.ImperativeAST.ArrayNode array = node.ArrayDimensions;`
	`679`	`+ var array = node.ArrayDimensions;`
`654`	`680`	`node = node.Expression;`
`655`	`681`	`node.ArrayDimensions = array;`
`656`	`682`	`}`
`657`		`- else if (node is ProtoCore.AST.AssociativeAST.GroupExpressionNode)`
	`683`	`+ else if (node is AST.AssociativeAST.GroupExpressionNode)`
`658`	`684`	`{`
`659`		`- ProtoCore.AST.AssociativeAST.ArrayNode array = node.ArrayDimensions;`
`660`		`- List<ProtoCore.AST.AssociativeAST.AssociativeNode> replicationGuides = node.ReplicationGuides;`
	`685`	`+ var array = node.ArrayDimensions;`
	`686`	`+ var replicationGuides = node.ReplicationGuides;`
`661`	`687`
`662`	`688`	`node = node.Expression;`
`663`	`689`	`node.ArrayDimensions = array;`
`664`	`690`	`node.ReplicationGuides = replicationGuides;`
`665`	`691`	`}`
`666`	`692`
`667`		`- if (node is ProtoCore.AST.ImperativeAST.IdentifierNode \|\| node is ProtoCore.AST.AssociativeAST.IdentifierNode)`
	`693`	`+ if (node is AST.ImperativeAST.IdentifierNode \|\| node is AST.AssociativeAST.IdentifierNode)`
`668`	`694`	`{`
`669`	`695`	`dynamic identnode = node;`
`670`	`696`
`@@ -723,7 +749,7 @@ protected bool DfsEmitIdentList(`
`723`	`749`	`}`
`724`	`750`	`else`
`725`	`751`	`{`
`726`		`- DSASM.DyanmicVariableNode dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Value, globalProcIndex, globalClassIndex);`
	`752`	`+ var dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Value, globalProcIndex, globalClassIndex);`
`727`	`753`	`core.DynamicVariableTable.variableTable.Add(dynamicVariableNode);`
`728`	`754`	`int dim = 0;`
`729`	`755`	`if (null != identnode.ArrayDimensions)`
`@@ -772,8 +798,8 @@ protected bool DfsEmitIdentList(`
`772`	`798`	`StackValue op = StackValue.Null;`
`773`	`799`	`if (0 == depth \|\| (symbolnode != null && symbolnode.isStatic))`
`774`	`800`	`{`
`775`		`- if (ProtoCore.DSASM.Constants.kGlobalScope == symbolnode.functionIndex`
`776`		`- && ProtoCore.DSASM.Constants.kInvalidIndex != symbolnode.classScope)`
	`801`	`+ if (Constants.kGlobalScope == symbolnode.functionIndex`
	`802`	`+ && Constants.kInvalidIndex != symbolnode.classScope)`
`777`	`803`	`{`
`778`	`804`	`// member var`
`779`	`805`	`if (symbolnode.isStatic)`
`@@ -806,7 +832,7 @@ protected bool DfsEmitIdentList(`
`806`	`832`	`else`
`807`	`833`	`{`
`808`	`834`	`// change to dynamic call to facilitate update mechanism`
`809`		`- DSASM.DyanmicVariableNode dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Name, globalProcIndex, globalClassIndex);`
	`835`	`+ var dynamicVariableNode = new DSASM.DyanmicVariableNode(identnode.Name, globalProcIndex, globalClassIndex);`
`810`	`836`	`core.DynamicVariableTable.variableTable.Add(dynamicVariableNode);`
`811`	`837`	`StackValue dynamicOp = StackValue.BuildDynamic(core.DynamicVariableTable.variableTable.Count - 1);`
`812`	`838`	`EmitInstrConsole(ProtoCore.DSASM.kw.pushm, identnode.Value + "[dynamic]");`
`@@ -828,7 +854,7 @@ protected bool DfsEmitIdentList(`
`828`	`854`	`}`
`829`	`855`	`return true;`
`830`	`856`	`}`
`831`		`- else if (node is ProtoCore.AST.ImperativeAST.FunctionCallNode \|\| node is ProtoCore.AST.AssociativeAST.FunctionCallNode)`
	`857`	`+ else if (node is AST.ImperativeAST.FunctionCallNode \|\| node is AST.AssociativeAST.FunctionCallNode)`
`832`	`858`	`{`
`833`	`859`	`// A function call must always track dependents`
`834`	`860`	`bool allowDependents = true;`
`@@ -842,7 +868,7 @@ protected bool DfsEmitIdentList(`
`842`	`868`	`{`
`843`	`869`	`ProtoCore.Utils.NodeUtils.SetNodeLocation(node, binaryExpNode, binaryExpNode);`
`844`	`870`	`}`
`845`		`- ProtoCore.DSASM.ProcedureNode procnode = TraverseFunctionCall(node, pNode, lefttype.UID, depth, ref finalType, graphNode, subPass, binaryExpNode);`
	`871`	`+ var procnode = TraverseFunctionCall(node, pNode, lefttype.UID, depth, ref finalType, graphNode, subPass, binaryExpNode);`
`846`	`872`
`847`	`873`	`// Restore the graphNode dependent state`
`848`	`874`	`if (null != graphNode)`
`@@ -2033,24 +2059,26 @@ protected void BuildRealDependencyForIdentList(AssociativeGraph.GraphNode graphN`
`2033`	`2059`	`}`
`2034`	`2060`	`}`
`2035`	`2061`
`2036`		`- protected void EmitIdentifierListNode(Node node, ref ProtoCore.Type inferedType, bool isBooleanOp = false,`
`2037`		`- ProtoCore.AssociativeGraph.GraphNode graphNode = null,`
`2038`		`- ProtoCore.CompilerDefinitions.SubCompilePass subPass = ProtoCore.CompilerDefinitions.SubCompilePass.None,`
`2039`		`- ProtoCore.AST.Node bnode = null)`
	`2062`	`+ protected void EmitIdentifierListNode(Node node,`
	`2063`	`+ ref Type inferedType,`
	`2064`	`+ bool isBooleanOp = false,`
	`2065`	`+ AssociativeGraph.GraphNode graphNode = null,`
	`2066`	`+ CompilerDefinitions.SubCompilePass subPass = CompilerDefinitions.SubCompilePass.None,`
	`2067`	`+ Node bnode = null)`
`2040`	`2068`	`{`
`2041`		`- if (subPass == ProtoCore.CompilerDefinitions.SubCompilePass.UnboundIdentifier)`
	`2069`	`+ if (subPass == CompilerDefinitions.SubCompilePass.UnboundIdentifier)`
`2042`	`2070`	`{`
`2043`	`2071`	`//to process all unbounded parameters if any`
`2044`	`2072`	`dynamic iNode = node;`
`2045`		`- while (iNode is ProtoCore.AST.AssociativeAST.IdentifierListNode \|\| iNode is ProtoCore.AST.ImperativeAST.IdentifierListNode)`
	`2073`	`+ while (iNode is AST.AssociativeAST.IdentifierListNode \|\| iNode is AST.ImperativeAST.IdentifierListNode)`
`2046`	`2074`	`{`
`2047`	`2075`	`dynamic rightNode = iNode.RightNode;`
`2048`		`- if (rightNode is ProtoCore.AST.AssociativeAST.FunctionCallNode \|\| rightNode is ProtoCore.AST.ImperativeAST.FunctionCallNode)`
	`2076`	`+ if (rightNode is AST.AssociativeAST.FunctionCallNode \|\| rightNode is AST.ImperativeAST.FunctionCallNode)`
`2049`	`2077`	`{`
`2050`	`2078`	`foreach (dynamic paramNode in rightNode.FormalArguments)`
`2051`	`2079`	`{`
`2052`		`- ProtoCore.Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);`
`2053`		`- DfsTraverse(paramNode, ref paramType, false, graphNode, ProtoCore.CompilerDefinitions.SubCompilePass.UnboundIdentifier);`
	`2080`	`+ Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0);`
	`2081`	`+ DfsTraverse(paramNode, ref paramType, false, graphNode, CompilerDefinitions.SubCompilePass.UnboundIdentifier);`
`2054`	`2082`	`}`
`2055`	`2083`	`}`
`2056`	`2084`	`iNode = iNode.LeftNode;`
`@@ -2060,16 +2088,16 @@ protected void EmitIdentifierListNode(Node node, ref ProtoCore.Type inferedType,`
`2060`	`2088`
`2061`	`2089`	`int depth = 0;`
`2062`	`2090`
`2063`		`- ProtoCore.Type leftType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.InvalidType, 0);`
	`2091`	`+ Type leftType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.InvalidType, 0);`
`2064`	`2092`
`2065`	`2093`	`BuildSSADependency(node, graphNode);`
`2066`	`2094`	`if (core.Options.GenerateSSA)`
`2067`	`2095`	`{`
`2068`	`2096`	`BuildRealDependencyForIdentList(graphNode);`
`2069`	`2097`
`2070`		`- if (node is ProtoCore.AST.AssociativeAST.IdentifierListNode)`
	`2098`	`+ if (node is AST.AssociativeAST.IdentifierListNode)`
`2071`	`2099`	`{`
`2072`		`- if ((node as ProtoCore.AST.AssociativeAST.IdentifierListNode).IsLastSSAIdentListFactor)`
	`2100`	`+ if ((node as AST.AssociativeAST.IdentifierListNode).IsLastSSAIdentListFactor)`
`2073`	`2101`	`{`
`2074`	`2102`	`Validity.Assert(null != ssaPointerStack);`
`2075`	`2103`	`ssaPointerStack.Pop();`