Fix filtering explicitly overridden targets in build components

Author: matkoch

source/Nuke.Common.Tests/Execution/DefaultInterfaceExecutionTest.cs

@@ -122,6 +122,16 @@ public void TestOverriddenDuplicatedTarget()
             targets.Count(x => x.Name == nameof(ITestBuild.D)).Should().Be(1);
         }
 
+        [Fact]
+        public void TestDeclaringAndImplementingComponent()
+        {
+            var build = new TestBuildWithDeclaringAndImplementingComponent();
+            var targets = ExecutableTargetFactory.CreateAll(build);
+
+            targets.Should().HaveCount(1);
+            targets.Single().Member.DeclaringType.Should().Be(typeof(IImplementingComponent));
+        }
+
         private interface IParameterInterface
             : INukeBuild
         {
@@ -215,5 +225,19 @@ private interface IDuplicatedTargetBuild
             public Target D => _ => _
                 .Executes(() => { });
         }
+
+        private class TestBuildWithDeclaringAndImplementingComponent : NukeBuild, IImplementingComponent
+        {
+        }
+
+        private interface IDeclaringComponent : INukeBuild
+        {
+            Target Foo { get; }
+        }
+
+        private interface IImplementingComponent : IDeclaringComponent
+        {
+            Target IDeclaringComponent.Foo => _ => _;
+        }
     }
 }

source/Nuke.Common/Execution/ExecutableTargetFactory.cs

@@ -94,7 +94,8 @@ internal static IEnumerable<PropertyInfo> GetTargetProperties(Type buildType)
             return buildType.GetAllMembers(
                 x => x is PropertyInfo property && property.PropertyType == typeof(Target),
                 bindingFlags: ReflectionUtility.Instance,
-                allowAmbiguity: false).Cast<PropertyInfo>();
+                allowAmbiguity: false,
+                filterQuasiOverridden: true).Cast<PropertyInfo>();
         }
     }
 }

source/Nuke.Common/Utilities/ReflectionUtility.cs

@@ -128,6 +128,11 @@ public static bool IsExtensionParameter(this ParameterInfo parameter)
                    method.GetParameters().First() == parameter;
         }
 
+        public static bool IsExplicit(this MemberInfo member)
+        {
+            return member.Name.Contains(".");
+        }
+
         public static string GetPossibleExplicitName(this MemberInfo member)
         {
             return $"{member.DeclaringType.NotNull().FullName.NotNull().Replace("+", ".")}.{member.Name}";
@@ -147,35 +152,53 @@ public static IEnumerable<MemberInfo> GetAllMembers(
             this Type buildType,
             Func<MemberInfo, bool> filter,
             BindingFlags bindingFlags,
-            bool allowAmbiguity)
+            bool allowAmbiguity,
+            bool filterQuasiOverridden = false)
         {
-            var interfaceMembers = buildType.GetInterfaces()
+            var interfaceMembersByName = buildType.GetInterfaces()
                 .SelectMany(x => x.GetMembers(bindingFlags))
                 .Where(filter)
-                .Where(x => buildType.GetMember(x.Name).SingleOrDefault() == null).ToLookup(x => x.Name);
+                .Where(x => buildType.GetMember(x.Name).SingleOrDefault() == null).ToLookup(x => x.GetDisplayShortName());
             var classMembers = buildType
                 .GetMembers(bindingFlags)
                 .Where(filter)
-                .Where(x => !x.Name.Contains(".")).ToDictionary(x => x.Name);
+                .Where(x => !x.IsExplicit()).ToDictionary(x => x.Name);
+            var removeMembers = new List<MemberInfo>();
 
-            foreach (var interfacePropertiesByName in interfaceMembers)
+            foreach (var interfaceMembers in interfaceMembersByName)
             {
-                var memberName = interfacePropertiesByName.Key;
-                var memberType = interfacePropertiesByName.First().MemberType;
+                var memberName = interfaceMembers.Key;
+                var memberType = interfaceMembers.First().MemberType;
                 var classMember = classMembers.GetValueOrDefault(memberName);
 
-                ControlFlow.Assert(allowAmbiguity || interfacePropertiesByName.Count() == 1 || classMember != null,
+                if (filterQuasiOverridden && classMember == null && interfaceMembers.Count() > 1)
+                {
+                    var orderedProperties = interfaceMembers
+                        .TSort(x => interfaceMembers.Where(y => y.DeclaringType.NotNull().IsAssignableFrom(x.DeclaringType))).ToList();
+
+                    var mostBaseType = orderedProperties.First().DeclaringType.NotNull();
+                    var derivedTypes = orderedProperties.Skip(1).Select(x => x.DeclaringType);
+                    if (derivedTypes.All(x => mostBaseType.IsAssignableFrom(x)))
+                    {
+                        removeMembers.AddRange(orderedProperties.Take(orderedProperties.Count - 1));
+                        continue;
+                    }
+                }
+
+                ControlFlow.Assert(allowAmbiguity || interfaceMembers.Count() == 1 || classMember != null,
                     new[] { $"{memberType} '{memberName}' must be implemented explicitly because it is inherited from multiple interfaces:" }
-                        .Concat(interfacePropertiesByName.Select(x => $" - {x.DeclaringType.NotNull().Name}"))
+                        .Concat(interfaceMembers.Select(x => $" - {x.DeclaringType.NotNull().Name}"))
                         .JoinNewLine());
+
                 ControlFlow.Assert(allowAmbiguity || classMember == null || classMember.IsPublic(),
                     new[] { $"{memberType} '{memberName}' must be marked public to override inherited member from:" }
-                        .Concat(interfacePropertiesByName.Select(x => $" - {x.DeclaringType.NotNull().Name}"))
+                        .Concat(interfaceMembers.Select(x => $" - {x.DeclaringType.NotNull().Name}"))
                         .JoinNewLine());
             }
 
             return classMembers.Values
-                .Concat(interfaceMembers.SelectMany(x => x).Select(x => x.GetImplementedOrInterfaceMember(buildType)))
+                .Concat(interfaceMembersByName.SelectMany(x => x).Select(x => x.GetImplementedOrInterfaceMember(buildType)))
+                .Except(removeMembers)
                 .Where(filter).ToList();
         }
     }