Crash when accessing static hidden methods from zero touch nodes

src/DynamoCore/Engine/CodeCompletion/CodeCompletionServices.cs

@@ -69,7 +69,7 @@ internal IEnumerable<CompletionData> GetCompletionsOnType(string code, string st
                 }
             }
 
-            return members?.Select(x => CompletionData.ConvertMirrorToCompletionData(x));
+            return members?.Distinct(new StaticMirrorNameComparer()).Select(x => CompletionData.ConvertMirrorToCompletionData(x));
         }
 
         /// <summary>
@@ -183,6 +183,7 @@ internal IEnumerable<CompletionData> GetFunctionSignatures(string code, string f
                     candidates = type.GetOverloadsOnInstance(functionName);
                 }
             }
+
             return candidates.Select(x => CompletionData.ConvertMirrorToCompletionData(x));
         }
 

src/Engine/ProtoCore/Lang/CallSite.cs

@@ -1118,23 +1118,26 @@ private FunctionEndPoint SelectFEPFromMultiple(StackFrame stackFrame, RuntimeCor
             Validity.Assert(svThisPtr.IsPointer,
                             "this pointer wasn't a pointer. {89635B06-AD53-4170-ADA5-065EB2AE5858}");
 
-            int typeID = svThisPtr.metaData.type;
 
-            //Test for exact match
-            List<FunctionEndPoint> exactFeps = new List<FunctionEndPoint>();
-
-            foreach (FunctionEndPoint fep in feps)
-                if (fep.ClassOwnerIndex == typeID)
-                    exactFeps.Add(fep);
+            // We have 2 possible cases here:
+            // 1. Static method call (i.e no this pointer)
+            //    Here we will cover the specific case of static method hiding.
+            //    We do not need to check actually if the method has the "IsHideBySig" (https://docs.microsoft.com/en-us/dotnet/api/system.reflection.methodbase.ishidebysig)
+            //    because static methods can only be hidden.
+            //    In this case we simply select the function that belongs to the calling class.
+            //    The assumption here is that all function end points in "feps" have already been checked that they have the same signature.
+            // 2. Method call from an instance of a class.
+            //    Try to match with methods of that class.
+            int typeID = svThisPtr.Pointer == Constants.kInvalidIndex ? stackFrame.ClassScope : svThisPtr.metaData.type;
 
-            if (exactFeps.Count == 1)
+            //Test for exact match
+            IEnumerable<FunctionEndPoint> exactFeps = feps.Where(x => x.ClassOwnerIndex == typeID);
+            if (exactFeps.Count() == 1)
             {
-                return exactFeps[0];
+                return exactFeps.First();
             }
-
-
+
             //Walk the class tree structure to find the method
-
             while (runtimeCore.DSExecutable.classTable.ClassNodes[typeID].Base != Constants.kInvalidIndex)
             {
                 typeID = runtimeCore.DSExecutable.classTable.ClassNodes[typeID].Base;
@@ -1149,15 +1152,15 @@ private FunctionEndPoint SelectFEPFromMultiple(StackFrame stackFrame, RuntimeCor
 
             foreach (FunctionEndPoint fep in feps)
             {
-                int noArbitraries = 0;
+                int numArbitraryRanks = 0;
 
                 for (int i = 0; i < argumentsList.Count; i++)
                 {
                     if (fep.FormalParams[i].rank == Constants.kArbitraryRank)
-                        noArbitraries++;
-
-                    numberOfArbitraryRanks.Add(noArbitraries);
+                        numArbitraryRanks++;
                 }
+
+                numberOfArbitraryRanks.Add(numArbitraryRanks);
             }
 
             int smallest = Int32.MaxValue;
@@ -1461,6 +1464,7 @@ private StackValue DispatchNew(
                     candidatesFeps.Add(fep);
                 }
             }
+
             funcGroup = new FunctionGroup(candidatesFeps);
 
             #endregion

src/Engine/ProtoCore/Reflection/Mirror.cs

@@ -213,6 +213,23 @@ public override string ToString()
             }
         }
 
+        //
+        /// <summary>
+        /// Comparer class that defines methods to support the comparison of StaticMirror objects for equality.
+        /// </summary>
+        internal class StaticMirrorNameComparer : IEqualityComparer<StaticMirror>
+        {
+            public bool Equals(StaticMirror x, StaticMirror y)
+            {
+                return x.Name == y.Name;
+            }
+
+            public int GetHashCode(StaticMirror obj)
+            {
+                return obj.Name.GetHashCode();
+            }
+        }
+
         /// <summary>
         ///  A ClassMirror object reflects upon the type of a single designscript variable
         ///  The information here is populated during the code generation phase
@@ -337,23 +354,30 @@ internal ClassMirror(StackValue svData, ProtoCore.Core core)
             /// <summary>
             /// Returns the constructors and static methods and properties 
             /// belonging to the type and its base types
+            /// Excludes hidden methods and properties from base types.
             /// </summary>
             /// <returns></returns>
             public IEnumerable<StaticMirror> GetMembers()
             {
                 // TODO: Factor out reflection functionality for both LibraryServices and Mirrors
                 List<StaticMirror> members = new List<StaticMirror>();
+                members.AddRange(GetConstructors().GroupBy(x => x.Name).Select(y => y.First()));
+                members.AddRange(GetFunctions().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+                members.AddRange(GetProperties().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+
+                // Filter out hidden functions/properties:
+                // Create a set of unique function, property and constructor descriptions.
+                // In this case we use ToString() to get the uniques description of the members (func signature, property names, constructor names).
+                var derivedClassMembers = new HashSet<string>();
+                members.ForEach(x => derivedClassMembers.Add(x.ToString()));
 
                 IEnumerable<ClassMirror> baseClasses = this.GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
-                    members.AddRange(baseClass.GetFunctions().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
-                    members.AddRange(baseClass.GetProperties().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+                    members.AddRange(baseClass.GetFunctions().Where(m => m.IsStatic && !derivedClassMembers.Contains(m.ToString())).GroupBy(x => x.Name).Select(y => y.First()));
+                    members.AddRange(baseClass.GetProperties().Where(m => m.IsStatic && !derivedClassMembers.Contains(m.ToString())).GroupBy(x => x.Name).Select(y => y.First()));
                 }
 
-                members.AddRange(this.GetConstructors().GroupBy(x => x.Name).Select(y => y.First()));
-                members.AddRange(this.GetFunctions().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
-                members.AddRange(this.GetProperties().Where(m => m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
                 return members;
             }
 
@@ -468,20 +492,28 @@ public IEnumerable<MethodMirror> GetOverloads(string methodName)
             /// <summary>
             /// Given a method name, return the matching list of 
             /// constructors or static methods on this type and its base types
+            /// Excludes hidden methods from base types.
             /// </summary>
             /// <param name="methodName"></param>
             /// <returns></returns>
             public IEnumerable<MethodMirror> GetOverloadsOnType(string methodName)
             {
                 List<MethodMirror> members = new List<MethodMirror>();
+                members.AddRange(this.GetConstructors().Where(x => x.MethodName == methodName));
+                members.AddRange(this.GetFunctions().Where(x => x.IsStatic && x.MethodName == methodName));
+
+                // Filter out hidden functions/properties:
+                // Create a set of unique function and constructor descriptions.
+                // In this case we use ToString() to get the uniques description of the members (func signature, constructor names).
+                var derivedClassMembers = new HashSet<string>();
+                members.ForEach(x => derivedClassMembers.Add(x.ToString()));
+
                 IEnumerable<ClassMirror> baseClasses = this.GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
-                    members.AddRange(baseClass.GetFunctions().Where(x => x.IsStatic && x.MethodName == methodName));
+                    members.AddRange(baseClass.GetFunctions().Where(x => x.IsStatic && x.MethodName == methodName && !derivedClassMembers.Contains(x.ToString())));
                 }
-
-                members.AddRange(this.GetConstructors().Where(x => x.MethodName == methodName));
-                members.AddRange(this.GetFunctions().Where(x => x.IsStatic && x.MethodName == methodName));
+
                 return members;
             }
 
@@ -504,20 +536,31 @@ public IEnumerable<MethodMirror> GetOverloadsOnInstance(string methodName)
                 return members;
             }
 
+            /// <summary>
+            /// Returns the instance methods and properties 
+            /// belonging to the type and its base types
+            /// Excludes hidden methods and properties from base types.
+            /// </summary>
             public IEnumerable<StaticMirror> GetInstanceMembers()
             {
                 // TODO: Factor out reflection functionality for both LibraryServices and Mirrors
                 List<StaticMirror> members = new List<StaticMirror>();
+                members.AddRange(this.GetFunctions().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+                members.AddRange(this.GetProperties().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+
+                // Filter out hidden functions/properties:
+                // Create a set of unique function and property descriptions.
+                // In this case we use ToString() to get the uniques description of the members (func signature, property names).
+                var derivedClassMembers = new HashSet<string>();
+                members.ForEach(x => derivedClassMembers.Add(x.ToString()));
 
                 IEnumerable<ClassMirror> baseClasses = this.GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
-                    members.AddRange(baseClass.GetFunctions().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
-                    members.AddRange(baseClass.GetProperties().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
+                    members.AddRange(baseClass.GetFunctions().Where(m => !m.IsStatic && !derivedClassMembers.Contains(m.ToString())).GroupBy(x => x.Name).Select(y => y.First()));
+                    members.AddRange(baseClass.GetProperties().Where(m => !m.IsStatic && !derivedClassMembers.Contains(m.ToString())).GroupBy(x => x.Name).Select(y => y.First()));
                 }
 
-                members.AddRange(this.GetFunctions().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
-                members.AddRange(this.GetProperties().Where(m => !m.IsStatic).GroupBy(x => x.Name).Select(y => y.First()));
                 return members;
             }