simplify and add test

DynamoDS · pinzart90 · Nov 12, 2020 · Nov 9, 2020 · Nov 9, 2020 · Nov 9, 2020
commit fc44db9961993c85ab8af5cec4a8a2fe22ffaadd
diff --git a/src/DynamoCore/Engine/CodeCompletion/CodeCompletionServices.cs b/src/DynamoCore/Engine/CodeCompletion/CodeCompletionServices.cs
@@ -69,7 +69,7 @@ internal IEnumerable<CompletionData> GetCompletionsOnType(string code, string st
                 }
             }
 
-            return members?.Distinct(new StaticMirrorNameComparer()).Select(x => CompletionData.ConvertMirrorToCompletionData(x));
+            return members?.Select(x => CompletionData.ConvertMirrorToCompletionData(x));
         }
 
         /// <summary>

diff --git a/src/Engine/ProtoCore/Reflection/Mirror.cs b/src/Engine/ProtoCore/Reflection/Mirror.cs
@@ -213,23 +213,6 @@ 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
@@ -352,33 +335,27 @@ 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.
+            /// Returns a list of constructors and static methods and properties 
+            /// belonging to the type and its base types. Filters out repeating names.
             /// </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()));
+                members.AddRange(GetConstructors());
+                members.AddRange(GetFunctions().Where(m => m.IsStatic));
+                members.AddRange(GetProperties().Where(m => m.IsStatic));
 
-                // 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();
+                IEnumerable<ClassMirror> baseClasses = GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
-                    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(baseClass.GetFunctions().Where(m => m.IsStatic));
+                    members.AddRange(baseClass.GetProperties().Where(m => m.IsStatic));
                 }
 
-                return members;
+                // Return a list of members with unique names.
+                return members.GroupBy(x => x.Name).Select(x => x.First()).ToList();
             }
 
             /// <summary>
@@ -499,16 +476,16 @@ public IEnumerable<MethodMirror> GetOverloads(string methodName)
             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));
+                members.AddRange(GetConstructors().Where(x => x.MethodName == methodName));
+                members.AddRange(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).
+                // In this case we use ToString() to get the unique 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();
+                IEnumerable<ClassMirror> baseClasses = GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
                     members.AddRange(baseClass.GetFunctions().Where(x => x.IsStatic && x.MethodName == methodName && !derivedClassMembers.Contains(x.ToString())));
@@ -526,42 +503,37 @@ public IEnumerable<MethodMirror> GetOverloadsOnType(string methodName)
             public IEnumerable<MethodMirror> GetOverloadsOnInstance(string methodName)
             {
                 List<MethodMirror> members = new List<MethodMirror>();
-                IEnumerable<ClassMirror> baseClasses = this.GetClassHierarchy();
+                IEnumerable<ClassMirror> baseClasses = GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
                     members.AddRange(baseClass.GetFunctions().Where(x => !x.IsStatic && x.MethodName == methodName));
                 }
 
-                members.AddRange(this.GetFunctions().Where(x => !x.IsStatic && x.MethodName == methodName));
+                members.AddRange(GetFunctions().Where(x => !x.IsStatic && x.MethodName == 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.
+            /// belonging to the type and its base types. Filters out repeating names.
             /// </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()));
+                List<StaticMirror> members = new List<StaticMirror>();
+                members.AddRange(GetFunctions().Where(m => !m.IsStatic));
+                members.AddRange(GetProperties().Where(m => !m.IsStatic));
 
-                IEnumerable<ClassMirror> baseClasses = this.GetClassHierarchy();
+                IEnumerable<ClassMirror> baseClasses = GetClassHierarchy();
                 foreach (var baseClass in baseClasses)
                 {
-                    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(baseClass.GetFunctions().Where(m => !m.IsStatic));
+                    members.AddRange(baseClass.GetProperties().Where(m => !m.IsStatic));
                 }
 
-                return members;
+                // Return a list of members with unique names.
+                return members.GroupBy(x => x.Name).Select(y => y.First()).ToList();
             }
 
             public ClassAttributes GetClassAttributes()

diff --git a/test/DynamoCoreTests/CodeBlockNodeTests.cs b/test/DynamoCoreTests/CodeBlockNodeTests.cs
@@ -2270,9 +2270,21 @@ public void TestCompletionOnDerivedTypeReturnsBaseType()
             var codeCompletionServices = new CodeCompletionServices(libraryServicesCore);
             var completions = codeCompletionServices.GetCompletionsOnType("", "DupTargetTest").ToList();
             Assert.AreEqual(3, completions.Count);
-            Assert.AreEqual("Foo", completions[0].Text);
-            Assert.AreEqual("DupTargetTest", completions[1].Text);
-            Assert.AreEqual("Bar", completions[2].Text);
+            Assert.AreEqual("DupTargetTest", completions[0].Text);
+            Assert.AreEqual("Bar", completions[1].Text);
+            Assert.AreEqual("Foo", completions[2].Text);
+        }
+
+        [Test]
+        [Category("UnitTests")]
+        public void TestCompletionOnDerivedTypeReturnsNonHiddenBaseMethods()
+        {
+            var codeCompletionServices = new CodeCompletionServices(libraryServicesCore);
+            var completions = codeCompletionServices.GetCompletionsOnType("", "FFITarget.DerivedTestHiddenMethods").ToList();
+            Assert.AreEqual(3, completions.Count);
+            Assert.AreEqual("DerivedTestHiddenMethods", completions[0].Text);
+            Assert.AreEqual("SomeStaticMethod", completions[1].Text);
+            Assert.AreEqual("SomeMethod", completions[2].Text);
         }
 
         [Test]

diff --git a/test/Engine/FFITarget/FFITarget.csproj b/test/Engine/FFITarget/FFITarget.csproj
@@ -77,6 +77,7 @@
     <Compile Include="ProtoFFITests.cs" />
     <Compile Include="RegressionTargets.cs" />
     <Compile Include="TestDefaultArgumentAttributes.cs" />
+    <Compile Include="TestHiddenMethods.cs" />
     <Compile Include="TestMessageLog.cs" />
     <Compile Include="TestMethodOverload.cs" />
     <Compile Include="TestNamespaceConflict.cs" />

diff --git a/test/Engine/FFITarget/TestHiddenMethods.cs b/test/Engine/FFITarget/TestHiddenMethods.cs
@@ -0,0 +1,53 @@
+using Autodesk.DesignScript.Runtime;
+
+namespace FFITarget
+{
+    public class BaseTestHiddenMethods
+    {
+        public static int SomeVariable = 100;
+        public BaseTestHiddenMethods()
+        {
+        }
+
+        public static int SomeStaticMethod()
+        {
+            return 100;
+        }
+        public static int SomeStaticMethod(int[] x)
+        {
+            return 100;
+        }
+        public static int SomeStaticMethod(int[] x, int[] y)
+        {
+            return 100;
+        }
+        public static int SomeMethod()
+        {
+            return 100;
+        }
+    }
+
+    public class DerivedTestHiddenMethods : BaseTestHiddenMethods
+    {
+        public static new int SomeVariable = 200;
+        public DerivedTestHiddenMethods()
+        {
+        }
+        public static new int SomeStaticMethod()
+        {
+            return 200;
+        }
+        public static new int SomeStaticMethod(int[] x)
+        {
+            return 200;
+        }
+        public static new int SomeStaticMethod(int[] x, int[] y)
+        {
+            return 200;
+        }
+        public static new int SomeMethod()
+        {
+            return 200;
+        }
+    }
+}
-Original file line number
+Diff line change
@@ Expand Up @@
                     }
                 }
-                return members?.Distinct(new StaticMirrorNameComparer()).Select(x => CompletionData.ConvertMirrorToCompletionData(x));
+                return members?.Select(x => CompletionData.ConvertMirrorToCompletionData(x));
             }
             /// <summary>
@@ Expand Down @@