feat: Added the ShowAllTypes property to the TypeOptions attribute

This property allows showing all types defined in a project in the dropdown.  Also the filtering of types was refactored to return IEnumerable instead of lists and arrays.

Author: SolidAlloy

Editor/Drawers/TypeDropdownDrawer.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq;
     using System.Reflection;
     using SolidUtilities;
     using UnityDropdown.Editor;
@@ -27,7 +28,7 @@ public TypeDropdownDrawer(Type selectedType, TypeOptionsAttribute attribute, Typ
 
         public void Draw(Action<Type> onTypeSelected)
         {
-            var dropdownItems = GetDropdownItems();
+            var dropdownItems = GetDropdownItems().ToList();
             SelectItem(dropdownItems, _selectedType);
 
             var dropdownMenu = new DropdownMenu<Type>(dropdownItems, onTypeSelected, ProjectSettings.SearchbarMinItemsCount, true, _attribute.ShowNoneElement);
@@ -38,34 +39,23 @@ public void Draw(Action<Type> onTypeSelected)
             dropdownMenu.ShowAsContext(_attribute.DropdownHeight);
         }
 
-        public DropdownItem<Type>[] GetDropdownItems()
+        public IEnumerable<DropdownItem<Type>> GetDropdownItems()
         {
-            var filteredTypes = GetFilteredTypes();
-            var includedTypes = GetIncludedTypes();
-
-            return includedTypes.Length == 0 ? filteredTypes : MergeArrays(filteredTypes, includedTypes);
+            return GetMainDropdownItems().Concat(GetIncludedTypes());
         }
 
-        private void SelectItem(DropdownItem<Type>[] dropdownItems, Type selectedType)
+        private void SelectItem(List<DropdownItem<Type>> dropdownItems, Type selectedType)
         {
             if (selectedType == null)
                 return;
 
-            var itemToSelect = Array.Find(dropdownItems, item => item.Value == selectedType);
+            var itemToSelect = dropdownItems.Find(item => item.Value == selectedType);
 
             if (itemToSelect != null)
                 itemToSelect.IsSelected = true;
         }
 
-        private DropdownItem<Type>[] MergeArrays(DropdownItem<Type>[] filteredTypes, DropdownItem<Type>[] includedTypes)
-        {
-            var totalTypes = new DropdownItem<Type>[filteredTypes.Length + includedTypes.Length];
-            filteredTypes.CopyTo(totalTypes, 0);
-            includedTypes.CopyTo(totalTypes, filteredTypes.Length);
-            return totalTypes;
-        }
-
-        private DropdownItem<Type>[] GetIncludedTypes()
+        private IEnumerable<DropdownItem<Type>> GetIncludedTypes()
         {
             if (_attribute.IncludeTypes == null)
                 return Array.Empty<DropdownItem<Type>>();
@@ -94,52 +84,43 @@ private DropdownItem<Type> CreateItem(Type type, Grouping grouping, string searc
             return new DropdownItem<Type>(type, TypeNameFormatter.Format(type, searchName, grouping), searchName: searchName);
         }
 
-        private DropdownItem<Type>[] GetFilteredTypes()
+        private IEnumerable<DropdownItem<Type>> GetMainDropdownItems()
         {
             bool containsMSCorLib = false;
+            var assemblies = _attribute.ShowAllTypes ? TypeCollector.GetAllAssemblies() : GetTypeRelatedAssemblies(out containsMSCorLib);
+            
+            if (_attribute.ShowAllTypes)
+                containsMSCorLib = true;
 
-            var typeRelatedAssemblies = ProjectSettings.UseBuiltInNames
-                ? TypeCollector.GetAssembliesTypeHasAccessTo(_declaringType, out containsMSCorLib)
-                : TypeCollector.GetAssembliesTypeHasAccessTo(_declaringType);
-
-            if (_attribute.IncludeAdditionalAssemblies != null)
-                IncludeAdditionalAssemblies(typeRelatedAssemblies);
-
-            var filteredTypes = TypeCollector.GetFilteredTypesFromAssemblies(typeRelatedAssemblies, _attribute);
+            var filteredTypes = TypeCollector.GetFilteredTypesFromAssemblies(assemblies, _attribute);
 
             bool replaceBuiltInNames = ProjectSettings.UseBuiltInNames && containsMSCorLib;
 
-            int filteredTypesLength = filteredTypes.Count;
-
-            var typeItems = new DropdownItem<Type>[filteredTypesLength];
-
-            for (int i = 0; i < filteredTypesLength; i++)
+            foreach (var filteredType in filteredTypes)
             {
-                var type = filteredTypes[i];
-
-                string fullTypeName = type.FullName;
+                string fullTypeName = filteredType.FullName;
                 Assert.IsNotNull(fullTypeName);
 
                 if (replaceBuiltInNames)
                     fullTypeName = fullTypeName.ReplaceWithBuiltInName(true);
 
-                typeItems[i] = CreateItem(type, _attribute.Grouping, fullTypeName);
+                yield return CreateItem(filteredType, _attribute.Grouping, fullTypeName);
             }
-
-            return typeItems;
         }
 
-        private void IncludeAdditionalAssemblies(List<Assembly> typeRelatedAssemblies)
+        private IEnumerable<Assembly> GetTypeRelatedAssemblies(out bool containsMSCorLib)
         {
-            foreach (string assemblyName in _attribute.IncludeAdditionalAssemblies)
-            {
-                var additionalAssembly = TypeCollector.TryLoadAssembly(assemblyName);
-                if (additionalAssembly == null)
-                    continue;
+            var typeRelatedAssemblies = TypeCollector.GetAssembliesTypeHasAccessTo(_declaringType, out containsMSCorLib);
 
-                if ( ! typeRelatedAssemblies.Contains(additionalAssembly))
-                    typeRelatedAssemblies.Add(additionalAssembly);
-            }
+            if (_attribute.IncludeAdditionalAssemblies != null)
+                typeRelatedAssemblies = typeRelatedAssemblies.Concat(GetAdditionalAssemblies());
+
+            return typeRelatedAssemblies;
+        }
+
+        private IEnumerable<Assembly> GetAdditionalAssemblies()
+        {
+            return _attribute.IncludeAdditionalAssemblies.Select(TypeCollector.TryLoadAssembly).Where(additionalAssembly => additionalAssembly != null);
         }
     }
 }

Editor/ProjectSettings.cs

@@ -34,6 +34,18 @@ public static bool UseBuiltInNames
             set => _useBuiltInNames.value = value;
         }
 
+        private static UserSetting<bool> _showAllTypes;
+
+        public static bool ShowAllTypes
+        {
+            get
+            {
+                InitializeIfNeeded();
+                return _showAllTypes.value;
+            }
+            set => _showAllTypes.value = value;
+        }
+
         private static void InitializeIfNeeded()
         {
             if (_instance != null)
@@ -43,6 +55,7 @@ private static void InitializeIfNeeded()
 
             _searchbarMinItemsCount = new UserSetting<int>(_instance, nameof(_searchbarMinItemsCount), 10);
             _useBuiltInNames = new UserSetting<bool>(_instance, nameof(_useBuiltInNames), true);
+            _showAllTypes = new UserSetting<bool>(_instance, nameof(_showAllTypes), false);
         }
     }
 }

Editor/ProjectSettingsDrawer.cs

@@ -13,6 +13,10 @@ internal static class ProjectSettingsDrawer
         private const string BuiltInLabel = "Use built-in names";
         private const string BuiltInTooltip = "Whether to make dropdown show built-in types by their keyword name (e.g. int) instead of the full name";
 
+        private const string ShowAllTypesLabel = "Show all types";
+        private const string ShowAllTypesTooltip =
+            "Whether to show all the types existing in the project in the dropdown. When disabled, only the types the declaring class can reference directly are shown in the dropdown.";
+
         [SettingsProvider]
         public static SettingsProvider CreateSettingsProvider()
         {
@@ -28,6 +32,7 @@ private static void OnGUI(string searchContext)
             using var _ = EditorGUIUtilityHelper.LabelWidthBlock(220f);
             ProjectSettings.SearchbarMinItemsCount = EditorGUILayout.IntField(new GUIContent(SearchbarLabel, SearchbarTooltip), ProjectSettings.SearchbarMinItemsCount, GUILayout.MaxWidth(300f));
             ProjectSettings.UseBuiltInNames = EditorGUILayout.Toggle(new GUIContent(BuiltInLabel, BuiltInTooltip), ProjectSettings.UseBuiltInNames);
+            ProjectSettings.ShowAllTypes = EditorGUILayout.Toggle(new GUIContent(ShowAllTypesLabel, ShowAllTypesTooltip), ProjectSettings.ShowAllTypes);
         }
 
         private static HashSet<string> GetKeywords()
@@ -37,6 +42,8 @@ private static HashSet<string> GetKeywords()
             keywords.AddWords(SearchbarTooltip);
             keywords.AddWords(BuiltInLabel);
             keywords.AddWords(BuiltInTooltip);
+            keywords.AddWords(ShowAllTypesLabel);
+            keywords.AddWords(ShowAllTypesTooltip);
             return keywords;
         }
 

Editor/Util/TypeCollector.cs

@@ -13,6 +13,8 @@
     /// </summary>
     internal static class TypeCollector
     {
+        private static readonly HashSet<string> _systemAssemblyNames = new HashSet<string> { "mscorlib", "System", "System.Core" };
+
         /// <summary>
         /// Collects assemblies the type has access to: the type's native assembly and all its referenced assemblies.
         /// </summary>
@@ -25,92 +27,38 @@ internal static class TypeCollector
         /// Additional assemblies may be added using <see cref="TypeOptionsAttribute.IncludeAdditionalAssemblies"/>,
         /// hence the List return type.
         /// </remarks>
-        public static List<Assembly> GetAssembliesTypeHasAccessTo(Type type)
-        {
-            Assembly typeAssembly;
-
-            try
-            {
-                typeAssembly = type == null ? Assembly.Load("Assembly-CSharp") : type.Assembly;
-            }
-            catch (FileNotFoundException)
-            {
-                return GetAllAssemblies();
-            }
-
-            var referencedAssemblies = typeAssembly.GetReferencedAssemblies();
-            var assemblies = new List<Assembly>(referencedAssemblies.Length + 1);
-
-            for (int i = 0; i < referencedAssemblies.Length; i++)
-            {
-                assemblies[i] = Assembly.Load(referencedAssemblies[i]);
-            }
-
-            assemblies[referencedAssemblies.Length] = typeAssembly;
-            return assemblies;
-        }
-
-        public static List<Assembly> GetAssembliesTypeHasAccessTo(Type type, out bool containsMscorlib)
+        public static IEnumerable<Assembly> GetAssembliesTypeHasAccessTo(Type type, out bool containsSystemAssembly)
         {
             if (type == null)
             {
-                containsMscorlib = true;
+                containsSystemAssembly = true;
                 return GetAllAssemblies();
             }
 
-            containsMscorlib = false;
+            containsSystemAssembly = false;
             Assembly typeAssembly = type.Assembly;
 
             var referencedAssemblies = typeAssembly.GetReferencedAssemblies();
-            var assemblies = new List<Assembly>(referencedAssemblies.Length + 1);
-
-            for (int i = 0; i < referencedAssemblies.Length; i++)
-            {
-                var assemblyName = referencedAssemblies[i];
-
-                if ( ! containsMscorlib && assemblyName.Name == "mscorlib")
-                {
-                    containsMscorlib = true;
-                }
-
-                assemblies.Add(Assembly.Load(assemblyName));
-            }
-
-            if ( ! containsMscorlib && typeAssembly.FullName.Contains("mscorlib"))
-            {
-                containsMscorlib = true;
-            }
 
-            assemblies.Add(typeAssembly);
-
-            return assemblies;
+            containsSystemAssembly = IsSystemAssembly(typeAssembly) || referencedAssemblies.Any(IsSystemAssembly);
+            return referencedAssemblies.Select(Assembly.Load).Append(typeAssembly);
         }
 
-        private static List<Assembly> GetAllAssemblies()
+        private static bool IsSystemAssembly(Assembly assembly)
         {
-            return new List<Assembly>(AppDomain.CurrentDomain.GetAssemblies());
+            return IsSystemAssembly(assembly.GetName());
         }
-
-        public static List<Type> GetFilteredTypesFromAssemblies(
-            List<Assembly> assemblies,
-            TypeOptionsAttribute filter)
+        
+        private static bool IsSystemAssembly(AssemblyName assemblyName)
         {
-            int assembliesCount = assemblies.Count;
-
-            var types = new List<Type>(assembliesCount * 20);
-
-            for (int i = 0; i < assembliesCount; i++)
-            {
-                var filteredTypes = GetFilteredTypesFromAssembly(assemblies[i], filter);
-                int filteredTypesCount = filteredTypes.Count;
+            return _systemAssemblyNames.Contains(assemblyName.Name);
+        }
 
-                for (int j = 0; j < filteredTypesCount; j++)
-                {
-                    types.Add(filteredTypes[j]);
-                }
-            }
+        public static IEnumerable<Assembly> GetAllAssemblies() => AppDomain.CurrentDomain.GetAssemblies();
 
-            return types;
+        public static IEnumerable<Type> GetFilteredTypesFromAssemblies(IEnumerable<Assembly> assemblies, TypeOptionsAttribute filter)
+        {
+            return assemblies.SelectMany(assembly => GetFilteredTypesFromAssembly(assembly, filter));
         }
 
         public static Assembly TryLoadAssembly(string assemblyName)
@@ -140,66 +88,37 @@ public static Assembly TryLoadAssembly(string assemblyName)
             return assembly;
         }
 
-        private static List<Type> GetFilteredTypesFromAssembly(Assembly assembly, TypeOptionsAttribute filter)
+        private static IEnumerable<Type> GetFilteredTypesFromAssembly(Assembly assembly, TypeOptionsAttribute filter)
         {
-            List<Type> assemblyTypes;
-
-            assemblyTypes = filter.AllowInternal
-                ? GetAllTypesFromAssembly(assembly)
-                : GetVisibleTypesFromAssembly(assembly);
-
-            var filteredTypes = new List<Type>();
-            int visibleTypesCount = assemblyTypes.Count;
+            var assemblyTypes = GetAllTypesFromAssembly(assembly);
 
-            for (int i = 0; i < visibleTypesCount; i++)
-            {
-                Type type = assemblyTypes[i];
-                if (FilterConstraintIsSatisfied(filter, type))
-                {
-                    filteredTypes.Add(type);
-                }
-            }
+            // Don't allow internal types of mscorlib even if the AllowInternal property is set to true because it leads
+            // to a lot of garbage in the dropdown while it's almost impossible users will need a System internal class.
+            bool allowInternal = filter.AllowInternal && !IsSystemAssembly(assembly);
 
-            return filteredTypes;
+            return assemblyTypes.Where(type => (allowInternal || type.IsVisible) && FilterConstraintIsSatisfied(filter, type));
         }
 
-        private static List<Type> GetVisibleTypesFromAssembly(Assembly assembly)
+        private static IEnumerable<Type> GetAllTypesFromAssembly(Assembly assembly)
         {
             try
             {
-                var assemblyTypes = assembly.GetTypes();
-                var visibleTypes = new List<Type>(assemblyTypes.Length);
-
-                foreach (Type type in assemblyTypes)
-                {
-                    if (type.IsVisible)
-                        visibleTypes.Add(type);
-                }
-
-                return visibleTypes;
-            }
-            catch (ReflectionTypeLoadException e)
-            {
-                Debug.LogError($"Types could not be extracted from assembly {assembly}: {e.Message}");
-                return new List<Type>(0);
-            }
-        }
-
-        private static List<Type> GetAllTypesFromAssembly(Assembly assembly)
-        {
-            try
-            {
-                return assembly.GetTypes().ToList();
+                return assembly.GetTypes();
             }
             catch (ReflectionTypeLoadException e)
             {
                 Debug.LogError($"Types could not be extracted from assembly {assembly}: {e.Message}");
-                return new List<Type>(0);
+                return Enumerable.Empty<Type>();
             }
         }
 
         private static bool FilterConstraintIsSatisfied(TypeOptionsAttribute filter, Type type)
         {
+            string typeFullName = type.FullName;
+            
+            if (typeFullName == null || typeFullName.StartsWith("<") || type.Name.StartsWith("<"))
+                return false;
+
             return filter == null || filter.MatchesRequirements(type);
         }
     }