public void TestSpecializedGenericTypesEquality()
{
// class Foo[T](val id: T)
// class SecondFoo[A](id: Int, val name: A) extends Foo[Int](id)
RType fooTy = new RType("Foo");
fooTy.DefineGenericParameters("T");
RType intFooTy = fooTy.MakeGenericType(IntTy);
RType secondTy = new RType("SecondFoo");
secondTy.DefineGenericParameters("A");
secondTy.BaseType = intFooTy;
Assert.IsTrue(secondTy.IsGenericType);
Assert.IsTrue(secondTy.IsGenericTypeDefinition);
Assert.IsTrue(intFooTy.IsAssignable(secondTy));
}
private static RType CreateArrayType()
{
RType arrayType = new RType("Array") {IsArray = true};
RppGenericParameter genericParameter = arrayType.DefineGenericParameters("A")[0];
arrayType.DefineConstructor(RMethodAttributes.Public, new[] {new RppParameterInfo("size", IntTy)});
arrayType.DefineMethod("length", RMethodAttributes.Public, IntTy, new RppParameterInfo[0]);
arrayType.DefineMethod("apply", RMethodAttributes.Public, genericParameter.Type, new[] {new RppParameterInfo("index", IntTy)},
new RppGenericParameter[0]);
arrayType.DefineMethod("update", RMethodAttributes.Public, UnitTy,
new[] {new RppParameterInfo("index", IntTy), new RppParameterInfo("value", genericParameter.Type)}, new RppGenericParameter[0]);
return arrayType;
}
public void TestOneGenericContainerWith2DistinctClasses()
{
// class List[A]
// class Apple
// class Orange
// listOfApples = new List[Apple]()
// listOfOranges = new List[Orange]()
RType listTy = new RType("List");
listTy.DefineGenericParameters("A");
RType appleTy = new RType("Apple");
RType listOfApplesTy = listTy.MakeGenericType(appleTy);
RType orangeTy = new RType("Orange");
RType listOfOrangesTy = listTy.MakeGenericType(orangeTy);
Assert.IsFalse(listOfOrangesTy.IsAssignable(listOfApplesTy));
Assert.IsFalse(listOfApplesTy.IsAssignable(listOfOrangesTy));
Assert.IsTrue(listOfOrangesTy.IsAssignable(listOfOrangesTy));
}
public void TestAssigningNothing()
{
RType optionTy = new RType("Option");
RppGenericParameter[] genericParameters = optionTy.DefineGenericParameters("A");
genericParameters[0].Variance = RppGenericParameterVariance.Covariant;
RType nothingOptionTy = optionTy.MakeGenericType(NothingTy);
RType stringOptionTy = optionTy.MakeGenericType(StringTy);
Assert.IsTrue(stringOptionTy.IsAssignable(nothingOptionTy));
}
public void ExtendingSpecializedGenericAndDefineOneMoreGenericParameter()
{
// class Foo[T]
// class SecondFoo[A] extends Foo[Int]
// Foo[Int] = SecondFoo[String]
RType fooTy = new RType("Foo");
fooTy.DefineGenericParameters("T");
RType intFooTy = fooTy.MakeGenericType(IntTy);
RType secondFooTy = new RType("SecondFoo", RTypeAttributes.Class, intFooTy);
Assert.IsTrue(intFooTy.IsAssignable(secondFooTy));
}
/// <summary>
/// Creates 2 types, List[Fruit] and List[Apple], where:
/// <code>
/// class List[A]
/// class Fruit
/// class Apple extends Fruit
/// </code>
/// </summary>
/// <param name="variance">variance type for type argument <code>'A'</code></param>
/// <param name="listOfFruits"></param>
/// <param name="listOfApples"></param>
private static void CreateTypes(RppGenericParameterVariance variance, out RType listOfFruits, out RType listOfApples)
{
RType listTy = new RType("List");
RppGenericParameter[] genericParameters = listTy.DefineGenericParameters("A");
genericParameters[0].Variance = variance;
RType fruitTy = new RType("Fruit");
RType listOfFruitsTy = listTy.MakeGenericType(fruitTy);
RType appleTy = new RType("Apple", RTypeAttributes.Class, fruitTy);
listOfApples = listTy.MakeGenericType(appleTy);
listOfFruits = listOfFruitsTy;
}
public void InflateSimpleGeneric()
{
/*
class Foo[A,B]{
def get(x: A, y: B): B
}
*/
RType fooTy = new RType("Foo");
RppGenericParameter[] gp = fooTy.DefineGenericParameters("A", "B");
fooTy.DefineMethod("get", RMethodAttributes.Public, gp[0].Type, new[] {new RppParameterInfo(gp[0].Type), new RppParameterInfo(gp[1].Type)});
// Foo[Int, Float]
RType specializedFooTy = fooTy.MakeGenericType(IntTy, FloatTy);
// get(x: Int) : Float
RppMethodInfo getMethod = specializedFooTy.Methods[0];
Assert.AreEqual(IntTy, getMethod.ReturnType);
Assert.AreEqual(IntTy, getMethod.Parameters[0].Type);
Assert.AreEqual(FloatTy, getMethod.Parameters[1].Type);
}
public void InflateClassWithGenericBaseType()
{
/*
class Foo[A, B] {
def get(x: A) : B
}
class Bar[A, B, C] extends Foo[A, B]
{
def map(x: A, y: B) : C
}
*/
RType fooTy = new RType("Foo");
{
RppGenericParameter[] gp = fooTy.DefineGenericParameters("X", "Y");
fooTy.DefineMethod("get", RMethodAttributes.Public, gp[1].Type, new[] {new RppParameterInfo(gp[0].Type)});
}
RType barTy = new RType("Bar");
RppGenericParameter[] barGp = barTy.DefineGenericParameters("A", "B", "C");
barTy.DefineMethod("map", RMethodAttributes.Public, barGp[2].Type, new[]
{
new RppParameterInfo(barGp[0].Type),
new RppParameterInfo(barGp[1].Type)
});
barTy.BaseType = fooTy.MakeGenericType(barGp[0].Type, barGp[1].Type);
RType specilizedBarTy = barTy.MakeGenericType(IntTy, FloatTy, StringTy);
Assert.IsNotNull(specilizedBarTy.BaseType);
IReadOnlyCollection<RType> barGenericArguments = specilizedBarTy.GenericArguments;
CollectionAssert.AreEqual(new[] {IntTy, FloatTy, StringTy}, barGenericArguments.ToList());
var fooGenericArguments = specilizedBarTy.BaseType.GenericArguments;
CollectionAssert.AreEqual(new[] {IntTy, FloatTy}, fooGenericArguments.ToList());
RppMethodInfo getMethod = specilizedBarTy.BaseType.Methods[0];
Assert.AreEqual(FloatTy, getMethod.ReturnType);
Assert.AreEqual(IntTy, getMethod.Parameters[0].Type);
}
private static RType CreateClosureType(int argCount)
{
RType closureTy = new RType("Function");
string[] genericNames = Enumerable.Range(0, argCount).Select(r => $"T{r + 1}").Concat("TResult").ToArray();
RppGenericParameter[] genericParams = closureTy.DefineGenericParameters(genericNames);
for (int i = 0; i < genericParams.Length - 1; i++)
{
genericParams[i].Variance = RppGenericParameterVariance.Contravariant;
}
genericParams[genericParams.Length - 1].Variance = RppGenericParameterVariance.Covariant;
return closureTy;
}
