private GenericDefinition Mark(Type definition, Dictionary <Type, GenericDefinition> context) { GenericDefinition result; if (context.TryGetValue(definition, out result)) { return(result); } result = new GenericDefinition { type = definition }; context.Add(definition, result); Type[] types; if (cache.TryGetValue(definition, out types)) { foreach (var type in types) { result.closures.Add(type); } } else if (definition.IsAbstract) { MarkInterface(result, context); } else { MarkImplementation(result, context); } return(result); }
private void MarkInterface(GenericDefinition definition, Dictionary <Type, GenericDefinition> context) { foreach (var implType in typesList.InheritorsOf(definition.type)) { var interfaceImpls = implType.ImplementationsOf(definition.type); if (implType.IsGenericType) { var markedImpl = Mark(implType, context); foreach (var interfaceImpl in interfaceImpls) { markedImpl.referers.Add(new GenericReferer { definition = definition, pattern = interfaceImpl, isInterface = true }); } } else { foreach (var interfaceImpl in interfaceImpls) { var closure = definition.type.TryCloseByPattern(definition.type, interfaceImpl); if (closure != null) { definition.closures.Add(closure); } } } } }
public override int GetHashCode() { var hashCode = (DeclaringType?.GetHashCode() ?? 0) ^ GenericDefinition.GetHashCode(); for (var i = 0; i < GenericArguments.Length; i++) { hashCode ^= GenericArguments[i].GetHashCode(); } return(hashCode); }
private void MarkImplementation(GenericDefinition definition, Dictionary <Type, GenericDefinition> context) { var ctor = definition.type.GetConstructor(); if (!ctor.isOk) { return; } var parameters = ctor.value.GetParameters(); var hasAnyGenericDependencies = false; foreach (var parameter in parameters) { var parameterType = parameter.ParameterType; if (parameterType.IsGenericType && (parameterType.GetGenericTypeDefinition() == typeof(IEnumerable <>) || parameterType.GetGenericTypeDefinition() == typeof(Func <>))) { parameterType = parameterType.GetGenericArguments()[0]; } if (parameterType.IsSimpleType()) { continue; } if (!assemblyFilter(parameterType.Assembly.GetName())) { continue; } if (!parameterType.IsGenericType) { continue; } if (!parameterType.ContainsGenericParameters) { continue; } if (parameterType.GenericParameters().Count != definition.type.GetGenericArguments().Length) { continue; } hasAnyGenericDependencies = true; Mark(parameterType.GetGenericTypeDefinition(), context).referers.Add(new GenericReferer { definition = definition, pattern = parameterType }); } if (!hasAnyGenericDependencies) { MarkImplementationConstraints(definition); } }
public GenericDefinition Copy() { var ret = new GenericDefinition() { MustBeClass = MustBeClass }; ret.Name = Name; ret.MustBeClass = MustBeClass; ret.GetterVariance = GetterVariance; ret.SetterVariance = SetterVariance; ret.BaseObjectGeneration = BaseObjectGeneration; ret.Loqui = Loqui; ret._whereSet.Add(_whereSet); ret._whereList.AddRange(_whereList); return(ret); }
private GenericDefinition Mark(Type definition, Dictionary<Type, GenericDefinition> context) { GenericDefinition result; if (context.TryGetValue(definition, out result)) return result; result = new GenericDefinition {type = definition}; context.Add(definition, result); Type[] types; if (cache.TryGetValue(definition, out types)) foreach (var type in types) result.closures.Add(type); else if (definition.IsAbstract) MarkInterface(result, context); else MarkImplementation(result, context); return result; }
private string GenericToString(GenericDefinition generic) { return("class " + generic.Name); }
private void MarkImplementationConstraints(GenericDefinition definition) { var genericArguments = definition.type.GetGenericArguments(); if (genericArguments.Length != 1) { return; } var constraints = genericArguments[0].GetGenericParameterConstraints(); if (constraints.Length == 0) { return; } foreach (var c in constraints) { if (!assemblyFilter(c.Assembly.GetName())) { return; } } var impls = typesList.InheritorsOf(constraints[0]); for (var i = 1; i < constraints.Length; i++) { if (impls.Count == 0) { return; } var current = typesList.InheritorsOf(constraints[i]); for (var j = impls.Count - 1; j >= 0; j--) { if (current.IndexOf(impls[j]) < 0) { impls.RemoveAt(j); } } } if (impls.Count == 0) { return; } var nonGenericOverrides = typesList.InheritorsOf(definition.type) .Where(x => !x.IsGenericType) .ToArray(); foreach (var impl in impls) { if (genericArguments[0].GenericParameterAttributes.HasFlag(GenericParameterAttributes.DefaultConstructorConstraint)) { if (impl.GetConstructor(Type.EmptyTypes) == null) { continue; } } var closedItem = definition.type.MakeGenericType(impl); var overriden = false; foreach (var nonGenericOverride in nonGenericOverrides) { if (closedItem.IsAssignableFrom(nonGenericOverride)) { overriden = true; break; } } if (!overriden) { definition.closures.Add(closedItem); } } }
private void MarkImplementation(GenericDefinition definition, Dictionary<Type, GenericDefinition> context) { var ctor = definition.type.GetConstructor(); if (!ctor.isOk) return; var parameters = ctor.value.GetParameters(); var hasAnyGenericDependencies = false; foreach (var parameter in parameters) { var parameterType = parameter.ParameterType; if (parameterType.IsGenericType && (parameterType.GetGenericTypeDefinition() == typeof (IEnumerable<>) || parameterType.GetGenericTypeDefinition() == typeof (Func<>))) parameterType = parameterType.GetGenericArguments()[0]; if (parameterType.IsSimpleType()) continue; if (!assemblyFilter(parameterType.Assembly.GetName())) continue; if (!parameterType.IsGenericType) continue; if (!parameterType.ContainsGenericParameters) continue; if (parameterType.GenericParameters().Count != definition.type.GetGenericArguments().Length) continue; hasAnyGenericDependencies = true; Mark(parameterType.GetGenericTypeDefinition(), context).referers.Add(new GenericReferer { definition = definition, pattern = parameterType }); } if (!hasAnyGenericDependencies) MarkImplementationConstraints(definition); }
private void MarkInterface(GenericDefinition definition, Dictionary<Type, GenericDefinition> context) { foreach (var implType in typesList.InheritorsOf(definition.type)) { var interfaceImpls = implType.ImplementationsOf(definition.type); if (implType.IsGenericType) { var markedImpl = Mark(implType, context); foreach (var interfaceImpl in interfaceImpls) markedImpl.referers.Add(new GenericReferer { definition = definition, pattern = interfaceImpl, isInterface = true }); } else foreach (var interfaceImpl in interfaceImpls) { var closure = definition.type.TryCloseByPattern(definition.type, interfaceImpl); if (closure != null) definition.closures.Add(closure); } } }
private void MarkImplementationConstraints(GenericDefinition definition) { var genericArguments = definition.type.GetGenericArguments(); if (genericArguments.Length != 1) return; var constraints = genericArguments[0].GetGenericParameterConstraints(); if (constraints.Length == 0) return; foreach (var c in constraints) if (!assemblyFilter(c.Assembly.GetName())) return; var impls = typesList.InheritorsOf(constraints[0]); for (var i = 1; i < constraints.Length; i++) { if (impls.Count == 0) return; var current = typesList.InheritorsOf(constraints[i]); for (var j = impls.Count - 1; j >= 0; j--) if (current.IndexOf(impls[j]) < 0) impls.RemoveAt(j); } if (impls.Count == 0) return; var nonGenericOverrides = typesList.InheritorsOf(definition.type) .Where(x => !x.IsGenericType) .ToArray(); foreach (var impl in impls) { if (genericArguments[0].GenericParameterAttributes.HasFlag(GenericParameterAttributes.DefaultConstructorConstraint)) if (impl.GetConstructor(Type.EmptyTypes) == null) continue; var closedItem = definition.type.MakeGenericType(impl); var overriden = false; foreach (var nonGenericOverride in nonGenericOverrides) if (closedItem.IsAssignableFrom(nonGenericOverride)) { overriden = true; break; } if (!overriden) definition.closures.Add(closedItem); } }
public GenericConditionalDefinition(GenericDefinition innerDef, Func <TypeInfo, PropertyInfo, bool> condition) { InnerDef = innerDef; Condition = condition; }