DynamoDS
diff --git a/‎src/DynamoCore/Graph/Nodes/Attributes.cs
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/DynamoCore/Graph/Nodes/Attributes.cs
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/Engine/ProtoCore/FFI/CLRDLLModule.cs
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎src/Engine/ProtoCore/FFI/CLRDLLModule.cs
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎src/Engine/ProtoCore/FFI/CLRFFIFunctionPointer.cs
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions b/‎src/Engine/ProtoCore/FFI/CLRFFIFunctionPointer.cs
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions
diff --git a/‎src/Engine/ProtoCore/FFI/CLRObjectMarshaler.cs
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/Engine/ProtoCore/FFI/CLRObjectMarshaler.cs
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/Engine/ProtoCore/Lang/CallSite.cs
Copy file name to clipboard
+55-17Lines changed: 55 additions & 17 deletions b/‎src/Engine/ProtoCore/Lang/CallSite.cs
Copy file name to clipboard
+55-17Lines changed: 55 additions & 17 deletions
diff --git a/‎src/Engine/ProtoCore/Lang/FunctionEndPoint.cs
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions b/‎src/Engine/ProtoCore/Lang/FunctionEndPoint.cs
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions
diff --git a/‎src/Engine/ProtoCore/Lang/Replication/ReplicationInstruction.cs
Copy file name to clipboard
+37-12Lines changed: 37 additions & 12 deletions b/‎src/Engine/ProtoCore/Lang/Replication/ReplicationInstruction.cs
Copy file name to clipboard
+37-12Lines changed: 37 additions & 12 deletions
@@ -200,7 +200,7 @@ public class IsMetaNodeAttribute : Attribute { }
     public class IsDesignScriptCompatibleAttribute : Attribute { }
 
     /// <summary>
-    ///    The NodeDescriptionAttribute indicates this node is obsolete
+    ///    The NodeObsoleteAttribute indicates this node is obsolete
     /// </summary>
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property)]
     public sealed class NodeObsoleteAttribute : IsObsoleteAttribute
 
@@ -1387,6 +1387,10 @@ public FFIMethodAttributes(MethodInfo method, Dictionary<MethodInfo, Attribute[]
                 {
                     IsLacingDisabled = true; 
                 }
+                else if (attr is AllowArrayPromotionAttribute)
+                {
+                    AllowArrayPromotion = (attr as AllowArrayPromotionAttribute).IsAllowed;
+                }
             }
         }
 
 
@@ -6,8 +6,11 @@
 using ProtoCore.DSASM;
 using ProtoCore.Utils;
 using Autodesk.DesignScript.Runtime;
+using DesignScript.Builtin;
 using ProtoCore.Properties;
 using ProtoCore.Exceptions;
+using IndexOutOfRangeException = DesignScript.Builtin.IndexOutOfRangeException;
+using KeyNotFoundException = DesignScript.Builtin.KeyNotFoundException;
 
 namespace ProtoFFI
 {
@@ -362,15 +365,35 @@ protected object InvokeFunctionPointerNoThrow(ProtoCore.Runtime.Context c, Inter
 
                         dsi.LogWarning(ProtoCore.Runtime.WarningID.InvalidArguments, msg);
                     }
+                    else if (exc is IndexOutOfRangeException)
+                    {
+                        dsi.LogWarning(ProtoCore.Runtime.WarningID.IndexOutOfRange, exc.Message);
+                    }
                     else if (exc is System.ArgumentException)
+                    {
                         dsi.LogWarning(ProtoCore.Runtime.WarningID.InvalidArguments, ErrorString(exc));
+                    }
                     else if (exc is System.NullReferenceException)
+                    {
                         dsi.LogWarning(ProtoCore.Runtime.WarningID.AccessViolation, ErrorString(null));
+                    }
+                    else if (exc is StringOverIndexingException)
+                    {
+                        dsi.LogWarning(ProtoCore.Runtime.WarningID.OverIndexing, exc.Message);
+                    }
+                    else if (exc is KeyNotFoundException)
+                    {
+                        dsi.LogWarning(ProtoCore.Runtime.WarningID.InvalidIndexing, exc.Message);
+                    }
                     else
+                    {
                         dsi.LogWarning(ProtoCore.Runtime.WarningID.AccessViolation, ErrorString(exc));
+                    }
                 }
                 else
+                {
                     dsi.LogWarning(ProtoCore.Runtime.WarningID.AccessViolation, ErrorString(ex));
+                }
             }
             catch (System.Reflection.TargetParameterCountException ex)
             {
@@ -421,7 +444,9 @@ protected object InvokeFunctionPointerNoThrow(ProtoCore.Runtime.Context c, Inter
                     dsi.LogWarning(ProtoCore.Runtime.WarningID.InvalidArguments, ErrorString(ex.InnerException));
                 }
                 else
+                {
                     dsi.LogWarning(ProtoCore.Runtime.WarningID.InvalidArguments, ErrorString(ex));
+                }
             }
             catch (Exception ex)
             {
@@ -441,9 +466,11 @@ private string ErrorString(System.Exception ex)
                 return ex.Message;
 
             string msg = (ex == null) ? "" : ex.Message;
+
             if (string.IsNullOrEmpty(msg) || msg.Contains("operation failed"))
                 return string.Format(Resources.OperationFailType1, ReflectionInfo.DeclaringType.Name, ReflectionInfo.Name);
 
+
             return string.Format(Resources.OperationFailType2, ReflectionInfo.DeclaringType.Name, ReflectionInfo.Name, msg);
         }
 
 
@@ -1325,7 +1325,7 @@ void core_Dispose(ProtoCore.RuntimeCore sender)
         {
             CLRObjectMarshaler marshaller = null;
             if (!mObjectMarshlers.TryGetValue(sender, out marshaller))
-                throw new KeyNotFoundException();
+                throw new System.Collections.Generic.KeyNotFoundException();
 
             mObjectMarshlers.Remove(sender);
 
 
@@ -809,22 +809,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 static bool 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;
                 }
@@ -842,13 +864,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))
+                        {
+                            // 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
 
@@ -857,7 +883,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;
                 }
@@ -868,16 +894,22 @@ private void ComputeFeps(
             {
                 if (arguments.Any(arg => arg.IsArray))
                 {
-                    foreach (List<ReplicationInstruction> replicationOption in replicationTrials)
+                    foreach (var replicationOption in replicationTrials)
                     {
                         FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);
                         if (compliantTarget != null)
                         {
-                            resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
-                            replicationInstructions = replicationOption;
-                            return;
+                            if (replicationInstructions == null ||
+                                IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))
+                            {
+                                resolvedFeps = new List<FunctionEndPoint>() {compliantTarget};
+                                replicationInstructions = replicationOption;
+                                matchFound = true;
+                            }
                         }
                     }
+                    if (matchFound)
+                        return;
                 }
             }
 
@@ -893,7 +925,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;
                     }
@@ -908,15 +940,21 @@ private void ComputeFeps(
                     FunctionEndPoint compliantTarget = GetLooseCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);
                     if (compliantTarget != null)
                     {
-                        resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };
-                        replicationInstructions = replicationOption;
-                        return;
+                        if (replicationInstructions == null ||
+                            IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))
+                        {
+                            resolvedFeps = new List<FunctionEndPoint>() {compliantTarget};
+                            replicationInstructions = replicationOption;
+                            matchFound = true;
+                        }
                     }
                 }
+                if (matchFound)
+                    return;
             }
             #endregion
 
-            resolvesFeps = new List<FunctionEndPoint>();
+            resolvedFeps = new List<FunctionEndPoint>();
             replicationInstructions = instructions;
         }
 
 
@@ -245,6 +245,17 @@ public int ComputeTypeDistance(List<StackValue> args, ProtoCore.DSASM.ClassTable
 
         public int GetConversionDistance(List<StackValue> reducedParamSVs, ProtoCore.DSASM.ClassTable classTable, bool allowArrayPromotion, RuntimeCore runtimeCore)
         {
+            // If the replication strategy allows array promotion, first check for the case
+            // where it could be disabled using the [AllowArrayPromotion(false)] attribute
+            // and if so set it from the attribute.
+            if (allowArrayPromotion)
+            {
+                var ma = procedureNode.MethodAttribute;
+                if (ma != null)
+                {
+                    allowArrayPromotion = ma.AllowArrayPromotion;
+                }
+            }
             int dist = ComputeTypeDistance(reducedParamSVs, classTable, runtimeCore, allowArrayPromotion);
             if (dist >= 0 && dist != (int)ProcedureDistance.MaxDistance) //Is it possible to convert to this type?
             {
 
@@ -1,5 +1,6 @@
-using System.Collections.Generic;
-using System.Text;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ProtoCore.Lang.Replication
 {
@@ -27,22 +28,46 @@ public struct ReplicationInstruction
 
         public override string ToString()
         {
-            if (!Zipped)
-                return "Cartesian, Index: " + CartesianIndex;
-            else
+            if (!Zipped) return "Cartesian, Index: " + CartesianIndex;
+
+            string indices = "";
+
+            for (int i = 0; i < ZipIndecies.Count - 1; i++)
             {
-                string indecies = "";
+                indices += ZipIndecies[i] + ", ";
+            }
 
-                for (int i = 0; i < ZipIndecies.Count - 1; i++)
-                    indecies += ZipIndecies[i] + ", ";
+            indices += ZipIndecies[ZipIndecies.Count - 1];
 
-                indecies += ZipIndecies[ZipIndecies.Count - 1];
+            indices += " - " + ZipAlgorithm;
 
-                indecies += " - " + ZipAlgorithm;
+            return "Zipped, indecies: " + indices;
 
-                return "Zipped, indecies: " + indecies;
-            }
+        }
+
+        public Boolean Equals(ReplicationInstruction other) {
 
+            if (this.Zipped == other.Zipped && this.ZipAlgorithm == other.ZipAlgorithm)
+            {
+                if (this.ZipIndecies == null && other.ZipIndecies == null)
+                {
+                    if (this.CartesianIndex == other.CartesianIndex) return true;
+
+                    return false;
+                }
+
+                if (this.ZipIndecies != null && other.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(other.ZipIndecies).ToList();
+                    var oldExcludescurrentList = other.ZipIndecies.Except(this.ZipIndecies).ToList();
+
+                    return !currentExcludesOldList.Any() && !oldExcludescurrentList.Any();
+                }
+            }
+            return false;
         }
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -1387,6 +1387,10 @@ public FFIMethodAttributes(MethodInfo method, Dictionary<MethodInfo, Attribute[]`
`1387`	`1387`	`{`
`1388`	`1388`	`IsLacingDisabled = true;`
`1389`	`1389`	`}`
	`1390`	`+ else if (attr is AllowArrayPromotionAttribute)`
	`1391`	`+ {`
	`1392`	`+ AllowArrayPromotion = (attr as AllowArrayPromotionAttribute).IsAllowed;`
	`1393`	`+ }`
`1390`	`1394`	`}`
`1391`	`1395`	`}`
`1392`	`1396`
Original file line number	Diff line number	Diff line change
`@@ -1325,7 +1325,7 @@ void core_Dispose(ProtoCore.RuntimeCore sender)`
`1325`	`1325`	`{`
`1326`	`1326`	`CLRObjectMarshaler marshaller = null;`
`1327`	`1327`	`if (!mObjectMarshlers.TryGetValue(sender, out marshaller))`
`1328`		`- throw new KeyNotFoundException();`
	`1328`	`+ throw new System.Collections.Generic.KeyNotFoundException();`
`1329`	`1329`
`1330`	`1330`	`mObjectMarshlers.Remove(sender);`
`1331`	`1331`
Original file line number	Diff line number	Diff line change
`@@ -809,22 +809,44 @@ private FunctionEndPoint GetLooseCompliantFEP(`
`809`	`809`	`return compliantTarget;`
`810`	`810`	`}`
`811`	`811`
	`812`	`+`
	`813`	`+ /// <summary>`
	`814`	`+ /// This helper function checks if the current replication option is`
	`815`	`+ /// similar to the previous option but of a higher rank.`
	`816`	`+ /// Checks if the first entry is same in both the options and the current options count is more.`
	`817`	`+ /// </summary>`
	`818`	`+ /// <returns>Returns true or false based on the condition described above.`
	`819`	`+ /// </returns>`
	`820`	`+ private static bool IsSimilarOptionButOfHigherRank(List<ReplicationInstruction> oldOption, List<ReplicationInstruction> newOption)`
	`821`	`+ {`
	`822`	`+ if (oldOption.Count > 0 && newOption.Count > 0 && oldOption.Count < newOption.Count)`
	`823`	`+ {`
	`824`	`+ if (oldOption[0].Equals(newOption[0]))`
	`825`	`+ return true;`
	`826`	`+ }`
	`827`	`+ return false;`
	`828`	`+ }`
	`829`	`+`
`812`	`830`	`private void ComputeFeps(`
`813`	`831`	`Context context,`
`814`	`832`	`List<StackValue> arguments,`
`815`	`833`	`FunctionGroup funcGroup,`
`816`	`834`	`List<ReplicationInstruction> instructions,`
`817`	`835`	`StackFrame stackFrame,`
`818`	`836`	`RuntimeCore runtimeCore,`
`819`		`- out List<FunctionEndPoint> resolvesFeps,`
	`837`	`+ out List<FunctionEndPoint> resolvedFeps,`
`820`	`838`	`out List<ReplicationInstruction> replicationInstructions)`
`821`	`839`	`{`
	`840`	`+ replicationInstructions = null;`
	`841`	`+ resolvedFeps = null;`
	`842`	`+ var matchFound = false;`
	`843`	`+`
`822`	`844`	`#region Case 1: Replication guide with exact match`
`823`	`845`	`{`
`824`	`846`	`FunctionEndPoint fep = GetCompleteMatchFunctionEndPoint(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);`
`825`	`847`	`if (fep != null)`
`826`	`848`	`{`
`827`		`- resolvesFeps = new List<FunctionEndPoint>() { fep };`
	`849`	`+ resolvedFeps = new List<FunctionEndPoint>() { fep };`
`828`	`850`	`replicationInstructions = instructions;`
`829`	`851`	`return;`
`830`	`852`	`}`
`@@ -842,13 +864,17 @@ private void ComputeFeps(`
`842`	`864`	`HashSet<FunctionEndPoint> lookups;`
`843`	`865`	`if (funcGroup.CanGetExactMatchStatics(context, reducedParams, stackFrame, runtimeCore, out lookups))`
`844`	`866`	`{`
`845`		`- //Otherwise we have a cluster of FEPs that can be used to dispatch the array`
`846`		`- resolvesFeps = new List<FunctionEndPoint>(lookups);`
`847`		`- replicationInstructions = replicationOption;`
`848`		`- return;`
	`867`	`+ if (replicationInstructions == null \|\| IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))`
	`868`	`+ {`
	`869`	`+ // We have a cluster of FEPs that can be used to dispatch the array`
	`870`	`+ resolvedFeps = new List<FunctionEndPoint>(lookups);`
	`871`	`+ replicationInstructions = replicationOption;`
	`872`	`+ matchFound = true;`
	`873`	`+ }`
`849`	`874`	`}`
`850`	`875`	`}`
`851`		`-`
	`876`	`+ if (matchFound)`
	`877`	`+ return;`
`852`	`878`	`}`
`853`	`879`	`#endregion`
`854`	`880`
`@@ -857,7 +883,7 @@ private void ComputeFeps(`
`857`	`883`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, instructions, stackFrame, runtimeCore);`
`858`	`884`	`if (compliantTarget != null)`
`859`	`885`	`{`
`860`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`886`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`861`	`887`	`replicationInstructions = instructions;`
`862`	`888`	`return;`
`863`	`889`	`}`
`@@ -868,16 +894,22 @@ private void ComputeFeps(`
`868`	`894`	`{`
`869`	`895`	`if (arguments.Any(arg => arg.IsArray))`
`870`	`896`	`{`
`871`		`- foreach (List<ReplicationInstruction> replicationOption in replicationTrials)`
	`897`	`+ foreach (var replicationOption in replicationTrials)`
`872`	`898`	`{`
`873`	`899`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);`
`874`	`900`	`if (compliantTarget != null)`
`875`	`901`	`{`
`876`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
`877`		`- replicationInstructions = replicationOption;`
`878`		`- return;`
	`902`	`+ if (replicationInstructions == null \|\|`
	`903`	`+ IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))`
	`904`	`+ {`
	`905`	`+ resolvedFeps = new List<FunctionEndPoint>() {compliantTarget};`
	`906`	`+ replicationInstructions = replicationOption;`
	`907`	`+ matchFound = true;`
	`908`	`+ }`
`879`	`909`	`}`
`880`	`910`	`}`
	`911`	`+ if (matchFound)`
	`912`	`+ return;`
`881`	`913`	`}`
`882`	`914`	`}`
`883`	`915`
`@@ -893,7 +925,7 @@ private void ComputeFeps(`
`893`	`925`	`FunctionEndPoint compliantTarget = GetCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore, true);`
`894`	`926`	`if (compliantTarget != null)`
`895`	`927`	`{`
`896`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
	`928`	`+ resolvedFeps = new List<FunctionEndPoint>() { compliantTarget };`
`897`	`929`	`replicationInstructions = replicationOption;`
`898`	`930`	`return;`
`899`	`931`	`}`
`@@ -908,15 +940,21 @@ private void ComputeFeps(`
`908`	`940`	`FunctionEndPoint compliantTarget = GetLooseCompliantFEP(context, arguments, funcGroup, replicationOption, stackFrame, runtimeCore);`
`909`	`941`	`if (compliantTarget != null)`
`910`	`942`	`{`
`911`		`- resolvesFeps = new List<FunctionEndPoint>() { compliantTarget };`
`912`		`- replicationInstructions = replicationOption;`
`913`		`- return;`
	`943`	`+ if (replicationInstructions == null \|\|`
	`944`	`+ IsSimilarOptionButOfHigherRank(replicationInstructions, replicationOption))`
	`945`	`+ {`
	`946`	`+ resolvedFeps = new List<FunctionEndPoint>() {compliantTarget};`
	`947`	`+ replicationInstructions = replicationOption;`
	`948`	`+ matchFound = true;`
	`949`	`+ }`
`914`	`950`	`}`
`915`	`951`	`}`
	`952`	`+ if (matchFound)`
	`953`	`+ return;`
`916`	`954`	`}`
`917`	`955`	`#endregion`
`918`	`956`
`919`		`- resolvesFeps = new List<FunctionEndPoint>();`
	`957`	`+ resolvedFeps = new List<FunctionEndPoint>();`
`920`	`958`	`replicationInstructions = instructions;`
`921`	`959`	`}`
`922`	`960`