feat: Allowed adding more than one base type for the Inherits attribute

It may come in handy when types implement multiple interfaces

Author: SolidAlloy

Runtime/Attributes/InheritsAttribute.cs

@@ -1,6 +1,8 @@
 namespace TypeReferences
 {
     using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using SolidUtilities.Extensions;
 
     /// <summary>
@@ -10,20 +12,18 @@
     [AttributeUsage(AttributeTargets.Field)]
     public class InheritsAttribute : TypeOptionsAttribute
     {
+        private readonly IEnumerable<Type> _baseTypes;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="InheritsAttribute"/> class.
         /// </summary>
         /// <param name="baseType">Type that selectable types must inherit from.</param>
-        public InheritsAttribute(Type baseType)
+        /// <param name="additionalBaseTypes">Additional types the selectable types must inherit from (e.g. multiple interfaces).</param>
+        public InheritsAttribute(Type baseType, params Type[] additionalBaseTypes)
         {
-            BaseType = baseType;
+            _baseTypes = additionalBaseTypes.Append(baseType);
         }
 
-        /// <summary>
-        /// Gets the type that selectable types must derive from.
-        /// </summary>
-        public Type BaseType { get; private set; }
-
         /// <summary>
         /// Allows to choose the base type from the drop-down as well.
         /// Defaults to a value of <c>false</c> unless explicitly specified.
@@ -34,25 +34,25 @@ public InheritsAttribute(Type baseType)
         /// Allows abstract classes and interfaces to be selected from drop-down.
         /// Defaults to a value of <c>false</c> unless explicitly specified.
         /// </summary>
-        public bool AllowAbstract { get; set; } = false;
+        public bool AllowAbstract { get; set; }
 
         /// <inheritdoc/>
         public override bool MatchesRequirements(Type type)
         {
-            if (type == BaseType && !IncludeBaseType)
+            if (_baseTypes.Contains(type) && !IncludeBaseType)
             {
                 return false;
             }
 
             // Include base type in the drop-down even if it is abstract.
             // If the user set IncludeBaseType to true, they probably want to include the base type in the dropdown
             // even though it is abstract.
-            if (type == BaseType)
+            if (_baseTypes.Contains(type))
                 return true;
 
             bool passesAbstractConstraint = AllowAbstract || !type.IsAbstract;
 
-            return type.InheritsFrom(BaseType) && passesAbstractConstraint && base.MatchesRequirements(type);
+            return _baseTypes.All(type.InheritsFrom) && passesAbstractConstraint && base.MatchesRequirements(type);
         }
     }
 }