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;
}
