TypeSystem.cs

/* Date: 1.8.2015, Time: 18:40 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using IllidanS4.SharpUtils.Collections.Sequences;

namespace IllidanS4.SharpUtils.Reflection
{
	/// <summary>
	/// Represents a portion of the types in the .NET type system.
	/// </summary>
	public class TypeSystem
	{
		public BindingFlags VisibilityFlags{get; private set;}
		public bool Arrays{get; private set;}
		public bool MDArrays{get; private set;}
		public bool Pointers{get; private set;}
		public bool ByRefs{get; private set;}
		public bool ReferenceTypePointers{get; private set;}
		public bool Generic{get; private set;}
		public bool GenericParameters{get; private set;}
		public bool DerivedFromStatic{get; private set;}
		public bool DerivedFromOpenGeneric{get; private set;}
		
		public static readonly TypeSystem Public = new TypeSystem(BindingFlags.Public);
		public static readonly TypeSystem Internal = new TypeSystem(BindingFlags.NonPublic | BindingFlags.Public);
		public static readonly TypeSystem Everything = new TypeSystem(BindingFlags.NonPublic | BindingFlags.Public, true, true, true, true, true, true, true, true, true);
		
		
		public TypeSystem(BindingFlags visibility) : this(visibility, true, true, true, true, true, true, true, false, false)
		{
			
		}
		
		public TypeSystem(BindingFlags visibility, bool arrays = true, bool mdarrays = true, bool byrefs = true, bool pointers = true, bool refpointers = true, bool generic = true, bool genparams = true, bool staticderived = false, bool opengenderived = false)
		{
			VisibilityFlags = visibility;
			Arrays = arrays;
			MDArrays = mdarrays;
			Pointers = pointers;
			ByRefs = byrefs;
			ReferenceTypePointers = refpointers;
			Generic = generic;
			GenericParameters = genparams;
			DerivedFromStatic = staticderived;
			DerivedFromOpenGeneric = opengenderived;
		}
		
		/// <summary>
		/// Enumerates all types defined in CommonLanguageRuntimeLibrary, that is mscorlib.dll.
		/// </summary>
		public IEnumerable<Type> CoreTypes{
			get{
				return ModuleTypes(Types.CommonLanguageRuntimeLibrary);
			}
		}
		
		/// <summary>
		/// Enumerates all types which have a type code assigned to them.
		/// </summary>
		public IEnumerable<Type> BasicTypes{
			get{
				var core = Types.Core;
				foreach(string val in Enum.GetNames(typeof(TypeCode)).Skip(1))
				{
					yield return core.GetType("System."+val);
				}
			}
		}
		
		/// <summary>
		/// Enumerates all primitive types.
		/// </summary>
		public IEnumerable<Type> PrimitiveTypes{
			get{
				return CoreTypes.Where(t => t.IsPrimitive);
			}
		}
		
		/// <summary>
		/// Enumerates all defined types in the current application domain.
		/// </summary>
		public IEnumerable<Type> DefinedTypes{
			get{
				return AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => AssemblyTypes(a));
			}
		}
		
		/// <summary>
		/// Enumerates all defined types and the fnptr type with its arrays.
		/// </summary>
		public IEnumerable<Type> ExtendedTypes{
			get{
				foreach(Type t in DefinedTypes)
				{
					yield return t;
				}
				if(ByRefs)
					yield return Types.Generated.FnPtrByRef;
				if(Pointers)
					yield return Types.Generated.FnPtrPointer;
				foreach(Type t in AllArrays(new FunctionPointerType()))
				{
					yield return t.UnderlyingSystemType;
				}
			}
		}
		
		/// <summary>
		/// Enumerates all extended types and types constructed from them.
		/// </summary>
		public IEnumerable<Type> PossibleTypes{
			get{
				return AllTypes(ExtendedTypes);
			}
		}
		
		/// <summary>
		/// Enumerates all types in an assembly.
		/// </summary>
		/// <param name="asm">The assembly containing the enumerated types.</param>
		public IEnumerable<Type> AssemblyTypes(Assembly asm)
		{
			return WithNested(asm.GetTypes());
		}
		
		/// <summary>
		/// Enumerates all types in a module.
		/// </summary>
		/// <param name="mod">The module containing the enumerated types.</param>
		public IEnumerable<Type> ModuleTypes(Module mod)
		{
			return WithNested(mod.GetTypes());
		}
		
		/// <summary>
		/// Enumerates all types constructed from the input.
		/// </summary>
		/// <param name="source">The input types.</param>
		public IEnumerable<Type> AllTypes(IEnumerable<Type> source)
		{
			return SequenceTools.SelectManyInfinite(AllGenericTypes(source).Select(t => AllDerivedRecursive(t)));
		}
		
		private IEnumerable<Type> AllGenericTypes(IEnumerable<Type> source)
		{
			if(Generic) return SequenceTools.SelectManyInfinite(source.Select(t => AllGenericItself(t, AllTypes(source))));
			else return source;
		}
		
		/// <summary>
		/// Enumerates source types and all types nested in them.
		/// </summary>
		/// <param name="types">The source types.</param>
		public IEnumerable<Type> WithNested(IEnumerable<Type> types)
		{
			foreach(Type t in types)
			{
				yield return t;
				foreach(Type t2 in AllNested(t))
				{
					yield return t2;
				}
			}
		}
		
		/// <summary>
		/// Enumerates all types nested in a type.
		/// </summary>
		/// <param name="type">The type containing nested types.</param>
		public IEnumerable<Type> AllNested(Type type)
		{
			foreach(Type t in type.GetNestedTypes(VisibilityFlags))
			{
				yield return t;
				foreach(Type t2 in AllNested(t))
				{
					yield return t2;
				}
			}
		}
		
		/// <summary>
		/// Enumerates all constructed types from a type.
		/// </summary>
		/// <param name="type">The source type.</param>
		public IEnumerable<Type> AllDerivedRecursive(Type type)
		{
			yield return type;
			foreach(Type t in AllDerivedBase(type))
			{
				yield return t;
			}
		}
		
		private IEnumerable<Type> AllDerivedBase(Type type)
		{
			if(
				!type.IsByRef && (!type.IsGenericTypeDefinition || DerivedFromOpenGeneric) &&
				(DerivedFromStatic || (!type.IsAbstract || !type.IsSealed))
			)
			{
				IEnumerable<Type> byrefs = Type.EmptyTypes;
				IEnumerable<Type> pointers = Type.EmptyTypes;
				if(Pointers)
				{
					if(ReferenceTypePointers || (type.IsValueType || type.IsPointer))
					{
						try{
							pointers = AllDerivedRecursive(type.MakePointerType());
						}catch(TypeLoadException)
						{
							
						}
					}
				}
				if(ByRefs)
				{
					try{
						byrefs = AllDerivedRecursive(type.MakeByRefType());
					}catch(TypeLoadException)
					{
						
					}
				}
				
				var arrays = AllArrays(type).Select(t => AllDerivedRecursive(t));
				
				return SequenceTools.SelectManyOuter(new[]{byrefs, pointers}.Concat(arrays));
			}else{
				return Type.EmptyTypes;
			}
		}
		
		private IEnumerable<Type> AllArrays(Type type)
		{
			if(Arrays)
			{
				Type arrt;
				try{
					arrt = type.MakeArrayType();
				}catch(TypeLoadException)
				{
					yield break;
				}
				yield return arrt;
				if(MDArrays) foreach(var arr in AllMDArrays(type)) yield return arr;
			}
		}
		
		/// <summary>
		/// Returns all MD array types created from a type.
		/// </summary>
		/// <param name="type">The element type of the arrays.</param>
		/// <returns>
		/// <paramref name="type"/>[*], <paramref name="type"/>[,], <paramref name="type"/>[,,] etc.
		/// Returns only arrays up to rank 32.
		/// </returns>
		public static IEnumerable<Type> AllMDArrays(Type type)
		{
			for(int i = 1; i <= 32; i++)
			{
				Type arr;
				try{
					arr = type.MakeArrayType(i);
				}catch(TypeLoadException)
				{
					yield break;
				}
				yield return arr;
			}
		}
		
		/// <summary>
		/// Returns all constructed generic types from a type. Also yields the definition.
		/// </summary>
		/// <param name="def">The type definition.</param>
		/// <param name="args">The possible type arguments.</param>
		public IEnumerable<Type> AllGenericItself(Type def, IEnumerable<Type> args)
		{
			yield return def;
			if(!def.IsGenericTypeDefinition) yield break;
			if(GenericParameters)
			{
				var tparams = def.GetGenericArguments();
				foreach(Type t in tparams)
				{
					yield return t;
				}
				args = SequenceTools.SelectManyOuter(args, tparams);
			}
			foreach(Type t in AllGeneric(def, args))
			{
				yield return t;
			}
		}
		
		/// <summary>
		/// Returns all constructed generic types from a type.
		/// </summary>
		/// <param name="def">The type definition.</param>
		/// <param name="args">The possible type arguments.</param>
		public IEnumerable<Type> AllGeneric(Type def, IEnumerable<Type> args)
		{
			if(!def.IsGenericTypeDefinition) return Type.EmptyTypes;
			Type[] tparams = def.GetGenericArguments();
			Type[] targs = new Type[tparams.Length];
			return SequenceTools.SelectManyInfinite(AllGenericBase(def, args, tparams, targs, 0));
		}
		
		private IEnumerable<IEnumerable<Type>> AllGenericBase(Type def, IEnumerable<Type> args, Type[] tparams, Type[] targs, int pos)
		{
			if(pos >= targs.Length)
			{
				Type con;
				try{
					con = def.MakeGenericType(targs);
				}catch(ArgumentException)
				{
					yield break;
				}
				yield return new Type[]{con};
			}else foreach(Type t in args)
			{
				if(!ConstraintsOkay(tparams[pos], t)) continue;
				targs[pos] = t;
				yield return SequenceTools.SelectManyInfinite(AllGenericBase(def, args, tparams, (Type[])targs.Clone(), pos+1));
			}
		}
		
		private static readonly Type nullableType = typeof(Nullable<>);
		
		private bool ConstraintsOkay(Type param, Type arg)
		{
			if(arg.IsPointer || arg.IsByRef) return false;
			if(!DerivedFromStatic && (arg.IsAbstract && arg.IsSealed)) return false;
			if(!DerivedFromOpenGeneric && arg.IsGenericTypeDefinition) return false;
			if((param.GenericParameterAttributes & GenericParameterAttributes.ReferenceTypeConstraint) != 0)
			{
				if(arg.IsValueType) return false;
			}
			if((param.GenericParameterAttributes & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
			{
				if(!arg.IsValueType) return false;
				if(arg.GetGenericTypeDefinition() == nullableType) return false;
			}
			if((param.GenericParameterAttributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0)
			{
				if(arg.GetConstructor(Type.EmptyTypes) == null) return false;
			}
			var constr = param.GetGenericParameterConstraints();
			foreach(var c in constr)
			{
				if(!c.IsAssignableFrom(arg)) return false;
			}
			return true;
		}
	}
}