Add tie-break for method overloads in derived classes

Bonsai.Core.Tests/OverloadedCombinatorBuilderTests.cs

@@ -98,6 +98,40 @@ public IObservable<TSource> Process<TSource>(IObservable<Timestamped<TSource>> s
             }
         }
 
+        class HidingOverloadedCombinatorMock : OverloadedCombinatorMock
+        {
+            public new IObservable<double> Process(IObservable<double> source)
+            {
+                return source.Select(x => double.NaN);
+            }
+        }
+
+        class HidingSpecializedGenericOverloadedCombinatorMock : SpecializedGenericOverloadedCombinatorMock
+        {
+            public new IObservable<TSource> Process<TSource>(IObservable<Timestamped<TSource>> source)
+            {
+                return source.Select(x => default(TSource));
+            }
+        }
+
+        [Combinator]
+        class BaseVirtualCombinatorMock
+        {
+            public virtual IObservable<string> Process(IObservable<string> source) => source;
+        }
+
+        class DerivedOverrideCombinatorMock : BaseVirtualCombinatorMock
+        {
+            public override IObservable<string> Process(IObservable<string> source) => Observable.Return(string.Empty);
+        }
+
+        class DerivedOverrideOverloadedCombinatorMock : BaseVirtualCombinatorMock
+        {
+            public override IObservable<string> Process(IObservable<string> source) => source;
+
+            public IObservable<object> Process(IObservable<object> _) => Observable.Return(default(object));
+        }
+
         [TestMethod]
         public void Build_DoubleOverloadedMethodCalledWithDouble_ReturnsDoubleValue()
         {
@@ -187,5 +221,49 @@ public void Build_SpecializedGenericOverloadedMethod_ReturnsValue()
             var result = Last(resultProvider).Result;
             Assert.AreEqual(value, result);
         }
+
+        [TestMethod]
+        public void Build_HidingDoubleOverloadedMethodCalledWithDouble_ReturnsDoubleValue()
+        {
+            var value = 5.0;
+            var combinator = new HidingOverloadedCombinatorMock();
+            var source = CreateObservableExpression(Observable.Return(value));
+            var resultProvider = TestCombinatorBuilder<double>(combinator, source);
+            var result = Last(resultProvider).Result;
+            Assert.AreNotEqual(value, result);
+        }
+
+        [TestMethod]
+        public void Build_HidingSpecializedGenericOverloadedMethod_ReturnsValue()
+        {
+            var value = 5;
+            var combinator = new HidingSpecializedGenericOverloadedCombinatorMock();
+            var source = CreateObservableExpression(Observable.Return(value).Timestamp());
+            var resultProvider = TestCombinatorBuilder<int>(combinator, source);
+            var result = Last(resultProvider).Result;
+            Assert.AreNotEqual(value, result);
+        }
+
+        [TestMethod]
+        public void Build_DerivedOverrideMethodCalledWithString_ReturnsOverrideValue()
+        {
+            var value = "5";
+            var combinator = new DerivedOverrideCombinatorMock();
+            var source = CreateObservableExpression(Observable.Return(value));
+            var resultProvider = TestCombinatorBuilder<object>(combinator, source);
+            var result = Last(resultProvider).Result;
+            Assert.AreNotEqual(value, result);
+        }
+
+        [TestMethod]
+        public void Build_DerivedOverrideOverloadedMethodCalledWithString_ReturnsObjectValue()
+        {
+            var value = "5";
+            var combinator = new DerivedOverrideOverloadedCombinatorMock();
+            var source = CreateObservableExpression(Observable.Return(value));
+            var resultProvider = TestCombinatorBuilder<object>(combinator, source);
+            var result = Last(resultProvider).Result;
+            Assert.AreNotEqual(value, result);
+        }
     }
 }

Bonsai.Core/Expressions/ExpressionBuilder.cs

@@ -765,6 +765,7 @@ class CallCandidate
             internal static readonly CallCandidate Ambiguous = new CallCandidate();
             internal static readonly CallCandidate None = new CallCandidate();
             internal MethodBase method;
+            internal Type declaringType;
             internal Expression[] arguments;
             internal bool generic;
             internal bool expansion;
@@ -818,6 +819,9 @@ static CallCandidate OverloadResolution(IEnumerable<MethodBase> methods, params
                     return new CallCandidate
                     {
                         method = method,
+                        declaringType = method.IsVirtual
+                            ? ((MethodInfo)method).GetBaseDefinition().DeclaringType
+                            : method.DeclaringType,
                         arguments = callArguments,
                         generic = method.IsGenericMethod,
                         expansion = ParamExpansionRequired(parameters, argumentTypes),
@@ -853,6 +857,15 @@ static CallCandidate OverloadResolution(IEnumerable<MethodBase> methods, params
                     // skip self-test
                     if (i == j) continue;
 
+                    // exclude self if declaring type is base type of other; and vice-versa
+                    if (candidates[i].declaringType != candidates[j].declaringType)
+                    {
+                        if (candidates[i].declaringType.IsAssignableFrom(candidates[j].declaringType))
+                            candidates[i].excluded = true;
+                        else candidates[j].excluded = true;
+                        continue;
+                    }
+
                     // compare implicit type conversion
                     var comparison = CompareFunctionMember(
                         candidateParameters[i],