DYN-1722 (#9578)

reddyashish · web-flow · commit 62e1b5650ed6 · 2019-03-25T17:42:48.000-04:00
* DYN-1722

* Variable change name

* Update the callsite.cs

* Modifying the equals function.

* adding comments

* Test comments

* Changing variable name

* Adding zipAlgorithm check and comments.

* More Comments.
diff --git a/src/Engine/ProtoCore/Lang/CallSite.cs b/src/Engine/ProtoCore/Lang/CallSite.cs
@@ -822,22 +822,44 @@ private FunctionEndPoint GetLooseCompliantFEP(
             return compliantTarget;
         }
 
+
+        /// <summary>
+        /// This helper function checks if the current replication option is
+        /// similar to the previous option but of a higher rank. 
+        /// Checks if the first entry is same in both the options and the current options count is more. 
+        /// </summary>
+        /// <returns>Returns true or false based on the condition described above. 
+        /// </returns>
+        private Boolean IsSimilarOptionButOfHigherRank(List<ReplicationInstruction> oldOption, List<ReplicationInstruction> newOption)
+        {
+            if (oldOption.Count > 0 && newOption.Count > 0 && oldOption.Count < newOption.Count)
+            {
+                if (oldOption[0].Equals(newOption[0]))
+                    return true;
+            }
+            return false;
+        }
+
         private void ComputeFeps(
             Context context,
             List<StackValue> arguments,
             FunctionGroup funcGroup,
             List<ReplicationInstruction> instructions,
             StackFrame stackFrame,
             RuntimeCore runtimeCore,
-            out List<FunctionEndPoint> resolvesFeps,
+            out List<FunctionEndPoint> resolvedFeps,
             out List<ReplicationInstruction> replicationInstructions)
         {
+            replicationInstructions = null;
+            resolvedFeps = null;
+            var matchFound = false;
+
             #region Case 1: Replication guide with exact match 
             {
                 FunctionEndPoint fep = GetCompleteMatchFunctionEndPoint(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);
                 if (fep != null)
                 {
-                    resolvesFeps = new List<FunctionEndPoint>() { fep };
+                    resolvedFeps = new List<FunctionEndPoint>() { fep };
                     replicationInstructions = instructions;
                     return;
                 }
@@ -855,13 +877,17 @@ private void ComputeFeps(
                     HashSet<FunctionEndPoint> lookups;
                     if (funcGroup.CanGetExactMatchStatics(context, reducedParams, stackFrame, runtimeCore, out lookups))
                     {
-                        //Otherwise we have a cluster of FEPs that can be used to dispatch the array
-                        resolvesFeps = new List<FunctionEndPoint>(lookups);
-                        replicationInstructions = replicationOption;
-                        return;
+                        if (replicationInstructions == null || IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))
+                        {
+                            //Otherwise we have a cluster of FEPs that can be used to dispatch the array
+                            resolvedFeps = new List<FunctionEndPoint>(lookups);
+                            replicationInstructions = replicationOption;
+                            matchFound = true;
+                        }
                     }
                 }
-
+                if (matchFound)
+                    return;
             }
             #endregion
 
@@ -870,7 +896,7 @@ private void ComputeFeps(
                 FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);
                 if (compliantTarget != null)
                 {
-                    resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
+                    resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };
                     replicationInstructions = instructions;
                     return;
                 }
@@ -886,11 +912,13 @@ private void ComputeFeps(
                         FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);
                         if (compliantTarget != null)
                         {
-                            resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
+                            resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };
                             replicationInstructions = replicationOption;
-                            return;
+                            matchFound = true;
                         }
                     }
+                    if (matchFound)
+                        return;
                 }
             }
 
@@ -906,7 +934,7 @@ private void ComputeFeps(
                     FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore, true);
                     if (compliantTarget != null)
                     {
-                        resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
+                        resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };
                         replicationInstructions = replicationOption;
                         return;
                     }
@@ -921,15 +949,17 @@ private void ComputeFeps(
                     FunctionEndPoint compliantTarget = GetLooseCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);
                     if (compliantTarget != null)
                     {
-                        resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
+                        resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };
                         replicationInstructions = replicationOption;
-                        return;
+                        matchFound = true;
                     }
                 }
+                if (matchFound)
+                    return;
             }
             #endregion
 
-            resolvesFeps = new List<FunctionEndPoint>();
+            resolvedFeps = new List<FunctionEndPoint>();
             replicationInstructions = instructions;
         }
 
diff --git a/src/Engine/ProtoCore/Lang/Replication/ReplicationInstruction.cs b/src/Engine/ProtoCore/Lang/Replication/ReplicationInstruction.cs
@@ -1,5 +1,6 @@
-﻿using System.Collections.Generic;
-using System.Text;
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ProtoCore.Lang.Replication
 {
@@ -44,5 +45,26 @@ public override string ToString()
             }
 
         }
+
+        public Boolean Equals(ReplicationInstruction oldOption) {
+
+            if (this.Zipped == oldOption.Zipped && this.ZipAlgorithm == oldOption.ZipAlgorithm)
+            {
+                if (this.ZipIndecies == null && oldOption.ZipIndecies == null)
+                    return true;
+
+                if (this.ZipIndecies != null && oldOption.ZipIndecies != null)
+                {
+                    // Fastest way to compare all elements of 2 lists. 
+                    // Excluding one list from another list and checking if the leftover lists is empty or not. 
+                    // https://stackoverflow.com/questions/12795882/quickest-way-to-compare-two-list
+                    var currentExcludesOldList = this.ZipIndecies.Except(oldOption.ZipIndecies).ToList();
+                    var oldExcludescurrentList = oldOption.ZipIndecies.Except(this.ZipIndecies).ToList();
+
+                    return !currentExcludesOldList.Any() && !oldExcludescurrentList.Any();
+                }
+            }
+            return false;
+        }
     }
 }
diff --git a/test/Engine/ProtoTest/Associative/BuiltinMethodsTest.cs b/test/Engine/ProtoTest/Associative/BuiltinMethodsTest.cs
@@ -1069,7 +1069,7 @@ public void TestTryGetValuesFromDictionary08()
            thisTest.Verify("r", null);
        }
 
-        [Test, Category("Failure")]
+        [Test]
         public void TestTryGetValuesFromDictionary09()
         {
             string code = @"
diff --git a/test/Engine/ProtoTest/Associative/MethodResolution.cs b/test/Engine/ProtoTest/Associative/MethodResolution.cs
@@ -396,21 +396,5 @@ def qux2()
             thisTest.Verify("z1", 22);
             thisTest.Verify("z2", 22);
         }
-
-        [Test]
-        public void TestEmptyNestedListsForMethodResolution()
-        {
-            string code = @"import(""FFITarget.dll""); 
-pt = DummyPoint2D.ByCoordinates(0,0);
-l = [[],[pt]];
-px1 = DummyPoint2D.X(l);
-pt = DummyPoint2D.ByCoordinates(0,0);
-l2 = [[pt],[]];
-px2 = DummyPoint2D.X(l2);
-";
-            var mirror = thisTest.RunScriptSource(code);
-            thisTest.Verify("px1", new object[] { new object[] { }, new object[] { 0 } });
-            thisTest.Verify("px2", new object[] { new object[] { 0 }, new object[] { } });
-        }
     }
 }
diff --git a/test/Engine/ProtoTest/TD/Associative/Replication.cs b/test/Engine/ProtoTest/TD/Associative/Replication.cs
@@ -4926,7 +4926,70 @@ public void TestReplicationInInlineConditional()
             thisTest.RunScriptSource(code);
             thisTest.Verify("r", new object[] { 2, 5, 7 });
         }
-    }
 
+        // This tests the case 2 block in the computeFeps method(CallSite.cs line:943)
+        [Test]
+        public void TestReplicationWithEmptyListInNestedLists()
+        {
+            string code = @"import(""FFITarget.dll""); 
+pt = DummyPoint2D.ByCoordinates(0,0);
+l = [[],[pt]];
+px1 = DummyPoint2D.X(l);
+pt = DummyPoint2D.ByCoordinates(0,0);
+l2 = [[pt],[]];
+px2 = DummyPoint2D.X(l2);
+";
+            var mirror = thisTest.RunScriptSource(code);
+            thisTest.Verify("px1", new object[] { new object[] { }, new object[] { 0 } });
+            thisTest.Verify("px2", new object[] { new object[] { 0 }, new object[] { } });
+        }
+
+        // This tests the case 4 block in the computeFeps method(CallSite.cs line:943)
+        [Test]
+        public void TestReplicationWithNullElementInNestedLists()
+        {
+            string code = @"import(""FFITarget.dll""); 
+pt = DummyPoint2D.ByCoordinates(0,0);
+l = [null,[pt]];
+px1 = DummyPoint2D.X(l);
+pt = DummyPoint2D.ByCoordinates(0,0);
+l2 = [[pt],null];
+px2 = DummyPoint2D.X(l2);
+";
+
+            var mirror = thisTest.RunScriptSource(code);
+            thisTest.Verify("px1", new object[] { null, new object[] { 0 } });
+            thisTest.Verify("px2", new object[] { new object[] { 0 }, null });
+        }
+
+        // This tests the case:6 block in the computeFeps method(CallSite.cs line:943)
+        // input example for case 6: l4 and l5 lists. 
+        [Test]
+        public void TestReplicationWithArraysOfDifferentRanks()
+        {
+            string code = @"import(""FFITarget.dll"");
+t1 = [1, [2]];
+t2 = t1 + 5;
+pt = DummyPoint2D.ByCoordinates(0,0);
+l1 = [[[pt]],[pt]];
+px1 = DummyPoint2D.X(l1);
+l2 = [[pt],[[pt]]];
+px2 = DummyPoint2D.X(l2);
+l3 = [[null],[[pt]]];
+px3 = DummyPoint2D.X(l3);
+l4 = [3.3,[pt],[[pt]]];
+px4 = DummyPoint2D.X(l4);
+l5 = [""test"",[[pt]],[pt]];
+px5 = DummyPoint2D.X(l5);
+";
+            var mirror = thisTest.RunScriptSource(code);
+            thisTest.Verify("t2", new object[] { 6, new object[] { 7 } });
+            thisTest.Verify("px1", new object[] { new object[] { new object[] { 0 } }, new object[] { 0 } });
+            thisTest.Verify("px2", new object[] { new object[] { 0 }, new object[] { new object[] { 0 } } });
+            thisTest.Verify("px3", new object[] { new object[] { null }, new object[] { new object[] { 0 } } });
+            thisTest.Verify("px4", new object[] { null, new object[] { 0 }, new object[] { new object[] { 0 } } });
+            thisTest.Verify("px5", new object[] { null, new object[] { new object[] { 0 } }, new object[] { 0 } });
+        }
+    }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -822,22 +822,44 @@ private FunctionEndPoint GetLooseCompliantFEP(`
`822`	`822`	`return compliantTarget;`
`823`	`823`	`}`
`824`	`824`
	`825`	`+`
	`826`	`+ /// <summary>`
	`827`	`+ /// This helper function checks if the current replication option is`
	`828`	`+ /// similar to the previous option but of a higher rank.`
	`829`	`+ /// Checks if the first entry is same in both the options and the current options count is more.`
	`830`	`+ /// </summary>`
	`831`	`+ /// <returns>Returns true or false based on the condition described above.`
	`832`	`+ /// </returns>`
	`833`	`+ private Boolean IsSimilarOptionButOfHigherRank(List<ReplicationInstruction> oldOption, List<ReplicationInstruction> newOption)`
	`834`	`+ {`
	`835`	`+ if (oldOption.Count > 0 && newOption.Count > 0 && oldOption.Count < newOption.Count)`
	`836`	`+ {`
	`837`	`+ if (oldOption[0].Equals(newOption[0]))`
	`838`	`+ return true;`
	`839`	`+ }`
	`840`	`+ return false;`
	`841`	`+ }`
	`842`	`+`
`825`	`843`	`private void ComputeFeps(`
`826`	`844`	`Context context,`
`827`	`845`	`List<StackValue> arguments,`
`828`	`846`	`FunctionGroup funcGroup,`
`829`	`847`	`List<ReplicationInstruction> instructions,`
`830`	`848`	`StackFrame stackFrame,`
`831`	`849`	`RuntimeCore runtimeCore,`
`832`		`- out List<FunctionEndPoint> resolvesFeps,`
	`850`	`+ out List<FunctionEndPoint> resolvedFeps,`
`833`	`851`	`out List<ReplicationInstruction> replicationInstructions)`
`834`	`852`	`{`
	`853`	`+ replicationInstructions = null;`
	`854`	`+ resolvedFeps = null;`
	`855`	`+ var matchFound = false;`
	`856`	`+`
`835`	`857`	`#region Case 1: Replication guide with exact match`
`836`	`858`	`{`
`837`	`859`	`FunctionEndPoint fep = GetCompleteMatchFunctionEndPoint(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);`
`838`	`860`	`if (fep != null)`
`839`	`861`	`{`
`840`		`- resolvesFeps = new List<FunctionEndPoint>() { fep };`
	`862`	`+ resolvedFeps = new List<FunctionEndPoint>() { fep };`
`841`	`863`	`replicationInstructions = instructions;`
`842`	`864`	`return;`
`843`	`865`	`}`
`@@ -855,13 +877,17 @@ private void ComputeFeps(`
`855`	`877`	`HashSet<FunctionEndPoint> lookups;`
`856`	`878`	`if (funcGroup.CanGetExactMatchStatics(context, reducedParams, stackFrame, runtimeCore, out lookups))`
`857`	`879`	`{`
`858`		`- //Otherwise we have a cluster of FEPs that can be used to dispatch the array`
`859`		`- resolvesFeps = new List<FunctionEndPoint>(lookups);`
`860`		`- replicationInstructions = replicationOption;`
`861`		`- return;`
	`880`	`+ if (replicationInstructions == null \|\| IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))`
	`881`	`+ {`
	`882`	`+ //Otherwise we have a cluster of FEPs that can be used to dispatch the array`
	`883`	`+ resolvedFeps = new List<FunctionEndPoint>(lookups);`
	`884`	`+ replicationInstructions = replicationOption;`
	`885`	`+ matchFound = true;`
	`886`	`+ }`
`862`	`887`	`}`
`863`	`888`	`}`
`864`		`-`
	`889`	`+ if (matchFound)`
	`890`	`+ return;`
`865`	`891`	`}`
`866`	`892`	`#endregion`
`867`	`893`
`@@ -870,7 +896,7 @@ private void ComputeFeps(`
`870`	`896`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);`
`871`	`897`	`if (compliantTarget != null)`
`872`	`898`	`{`
`873`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`899`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`874`	`900`	`replicationInstructions = instructions;`
`875`	`901`	`return;`
`876`	`902`	`}`
`@@ -886,11 +912,13 @@ private void ComputeFeps(`
`886`	`912`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);`
`887`	`913`	`if (compliantTarget != null)`
`888`	`914`	`{`
`889`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`915`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`890`	`916`	`replicationInstructions = replicationOption;`
`891`		`- return;`
	`917`	`+ matchFound = true;`
`892`	`918`	`}`
`893`	`919`	`}`
	`920`	`+ if (matchFound)`
	`921`	`+ return;`
`894`	`922`	`}`
`895`	`923`	`}`
`896`	`924`
`@@ -906,7 +934,7 @@ private void ComputeFeps(`
`906`	`934`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore, true);`
`907`	`935`	`if (compliantTarget != null)`
`908`	`936`	`{`
`909`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`937`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`910`	`938`	`replicationInstructions = replicationOption;`
`911`	`939`	`return;`
`912`	`940`	`}`
`@@ -921,15 +949,17 @@ private void ComputeFeps(`
`921`	`949`	`FunctionEndPoint compliantTarget = GetLooseCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);`
`922`	`950`	`if (compliantTarget != null)`
`923`	`951`	`{`
`924`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`952`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`925`	`953`	`replicationInstructions = replicationOption;`
`926`		`- return;`
	`954`	`+ matchFound = true;`
`927`	`955`	`}`
`928`	`956`	`}`
	`957`	`+ if (matchFound)`
	`958`	`+ return;`
`929`	`959`	`}`
`930`	`960`	`#endregion`
`931`	`961`
`932`		`- resolvesFeps = new List<FunctionEndPoint>();`
	`962`	`+ resolvedFeps = new List<FunctionEndPoint>();`
`933`	`963`	`replicationInstructions = instructions;`
`934`	`964`	`}`
`935`	`965`
Original file line number	Diff line number	Diff line change
`@@ -1069,7 +1069,7 @@ public void TestTryGetValuesFromDictionary08()`
`1069`	`1069`	`thisTest.Verify("r", null);`
`1070`	`1070`	`}`
`1071`	`1071`
`1072`		`- [Test, Category("Failure")]`
	`1072`	`+ [Test]`
`1073`	`1073`	`public void TestTryGetValuesFromDictionary09()`
`1074`	`1074`	`{`
`1075`	`1075`	`string code = @"`