disallow usage of both [Service] and [ServiceInheritable]

in service binder and in schema generator.
Exception will be thrown.
+ unit tests.

Author: Meir Kriheli

src/protobuf-net.Grpc.Reflection/SchemaGenerator.cs

@@ -139,7 +139,7 @@ static Type ApplySubstitutes(Type type)
 
         private static MethodInfo[] GetMethodsRecursively(ServiceBinder serviceBinder, Type contractType)
         {
-            var includingInheritedInterfaces = ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(contractType);
+            var includingInheritedInterfaces = ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(serviceBinder, contractType);
 
             var inheritedMethods = includingInheritedInterfaces
                 .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Instance))

src/protobuf-net.Grpc/Configuration/ServerBinder.cs

@@ -52,7 +52,7 @@ public int Bind(object state, Type serviceType, BinderConfiguration? binderConfi
                 var serviceContract = potentialServiceContract;
 
                 var typesToBeIncludedInMethodsBinding =
-                    ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(serviceContract);
+                    ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(binderConfiguration.Binder, serviceContract);
 
                 // Per service contract, we will collect all the methods of inherited interfaces
                 // and bind them as they were defined in the service contract itself.

src/protobuf-net.Grpc/Internal/ContractOperation.cs

@@ -363,13 +363,15 @@ internal static ISet<Type> ExpandInterfaces(Type type)
             if (type.IsInterface) set.Add(type);
             return set;
         }
-        
+
         /// <summary>
         /// Collect all the types to be used for extracting methods for a specific Service Contract
         /// </summary>
+        /// <param name="serviceBinder"></param>
         /// <param name="serviceContract">Must be a service contract</param>
         /// <returns>types to be used for extracting methods</returns>
-        internal static ISet<Type> ExpandWithInterfacesMarkedAsServiceInheritable(Type serviceContract)
+        internal static ISet<Type> ExpandWithInterfacesMarkedAsServiceInheritable(ServiceBinder serviceBinder,
+            Type serviceContract)
         {
             var set = new HashSet<Type>();
 
@@ -384,8 +386,24 @@ internal static ISet<Type> ExpandWithInterfacesMarkedAsServiceInheritable(Type s
                     set.Add(t);
                 }
             }
+
+            ValidateServiceContracts(serviceBinder, set);
             return set;
         }
+
+        private static void ValidateServiceContracts(ServiceBinder serviceBinder, HashSet<Type> set)
+        {
+            foreach (var item in set)
+            {
+                if (item.IsDefined(typeof(ServiceInheritableAttribute)))
+                {
+                    if (serviceBinder.IsServiceContract(item, out var serviceName))
+                        throw new ArgumentException(
+                            $"Bad definition for service {serviceName}: " +
+                            $"A service contract cannot be marked as a service inheritable as well");
+                }
+            }
+        }
     }
 
     internal enum ContextKind

tests/protobuf-net.Grpc.Reflection.Test/SchemaGeneration.cs

@@ -324,6 +324,21 @@ public void WhenClassIsNotServiceContract_Throw()
             Assert.Throws<ArgumentException>(activation.Invoke);
         }
 
+
+        [Service]
+        [ServiceInheritable]
+        public interface IIServiceWithBothServiceAndServiceInheritableAttributes
+        {
+            void SomeMethod();
+        }
+        [Fact]
+        public void WhenInterfaceHasAttributesServiceAndServiceInheritable_Throw()
+        {
+            var generator = new SchemaGenerator();
+            Action activation = () => generator.GetSchema<IIServiceWithBothServiceAndServiceInheritableAttributes>();
+            Assert.Throws<ArgumentException>(activation.Invoke);
+        }
+
         [Service]
         public interface ISimpleService1
         {

tests/protobuf-net.Grpc.Test/ContractOperationTests.cs

@@ -82,6 +82,45 @@ public void CheckAllMethodsCovered()
 
             Assert.Empty(expected);
         }
+        
+        
+        [Service]
+        [ServiceInheritable]
+        public interface IIServiceWithBothServiceAndServiceInheritableAttributes
+        {
+            void SomeMethod();
+        }
+    
+        [Fact]
+        public void WhenInterfaceHasAttributesServiceAndServiceInheritable_Throw()
+        {
+            var config = BinderConfiguration.Default;
+            Action activation = () => ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(
+                config.Binder, 
+                typeof(IIServiceWithBothServiceAndServiceInheritableAttributes));
+            Assert.Throws<ArgumentException>(activation.Invoke);
+        }
+        
+        public class ServiceContractClassInheritsServiceAndServiceInheritableAttributes
+        : IIServiceWithBothServiceAndServiceInheritableAttributes, IGrpcService
+        {
+            public void SomeMethod()
+            {
+            }
+        }
+    
+        [Fact]
+        public void WhenServiceContractClassImplementsInterfaceHavingAttributesServiceAndServiceInheritable_Throw()
+        {
+            var config = BinderConfiguration.Default;
+            Action activation = () => ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(
+                config.Binder, 
+                typeof(ServiceContractClassInheritsServiceAndServiceInheritableAttributes));
+            Assert.Throws<ArgumentException>(activation.Invoke);
+        }
+
+        
+        
 #pragma warning disable CS0618 // Empty
         [Theory]
         [InlineData(nameof(IAllOptions.Client_AsyncUnary), typeof(HelloRequest), typeof(HelloReply), MethodType.Unary, (int)ContextKind.CallOptions, (int)ResultKind.Grpc, (int)VoidKind.None)]