private static void AssertOptimized(GenericTypeSlim type, int arity, params TypeSlim[] args)
{
Assert.IsTrue(type.GetType().Name.EndsWith(arity.ToString()));
Assert.AreEqual(arity, type.GenericArgumentCount);
for (var i = 0; i < args.Length; i++)
{
Assert.AreSame(args[i], type.GetGenericArgument(i));
}
var genArgs = type.GenericArguments;
Assert.AreSame(genArgs, type.GenericArguments);
Assert.AreEqual(arity, genArgs.Count);
for (var i = 0; i < args.Length; i++)
{
Assert.AreSame(args[i], genArgs[i]);
}
Assert.ThrowsException <ArgumentOutOfRangeException>(() => type.GetGenericArgument(-1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => type.GetGenericArgument(arity));
}
protected override System.Type MakeGeneric(GenericTypeSlim type, System.Type typeDefinition, ReadOnlyCollection <System.Type> arguments)
{
var res = default(System.Type);
if (typeDefinition != null && arguments.All(a => a != null))
{
res = typeDefinition.MakeGenericType(arguments.ToArray());
}
return(res);
}
private TypeRef AddTypeGeneric(GenericTypeSlim type, ReadOnlyCollection <TypeSlim> genericArguments)
{
var genericTypeDefinition = AddType(type.GenericTypeDefinition, genericArguments);
var genericTypeArgumentCount = type.GenericArgumentCount;
var genericTypeArguments = new TypeRef[genericTypeArgumentCount];
for (var i = 0; i < genericTypeArgumentCount; i++)
{
var argType = type.GetGenericArgument(i);
var typeRef = AddType(argType, genericArguments);
genericTypeArguments[i] = typeRef;
}
var index = _typeDefs.Count;
_typeDefs.Add(new GenericTypeDef(genericTypeDefinition, genericTypeArguments));
return(new SimpleTypeRef(index));
}
/// <summary>
/// Unifies generic types with awareness of the conversion from asynchronous to synchronous Reactive entity types.
/// </summary>
/// <param name="typeRich">The CLR type.</param>
/// <param name="typeSlim">The slim type.</param>
/// <returns>true if the unification was successful, false otherwise.</returns>
protected override bool UnifyGeneric(Type typeRich, GenericTypeSlim typeSlim)
{
var reactiveType = ReactiveEntityTypeExtensions.FromTypeSlim(typeSlim);
if ((reactiveType & ReactiveEntityType.Func) == ReactiveEntityType.Func)
{
reactiveType = ReactiveEntityType.Func;
}
return(reactiveType switch
{
ReactiveEntityType.Func => Unify(typeRich.GetGenericArguments(), typeSlim),
ReactiveEntityType.Observer or
ReactiveEntityType.Observable or
ReactiveEntityType.StreamFactory or
ReactiveEntityType.SubscriptionFactory or
ReactiveEntityType.Stream => Unify(GetEntityTypes(typeRich, reactiveType), typeSlim),
_ => base.UnifyGeneric(typeRich, typeSlim),
});
