public void RefReturn()
{
var arrayP = ParameterExpression.Create(new ArrayType(TypeSignature.String, 1), "a");
cx.AddTestExpr(Expression.ArrayIndex(
arrayP,
Expression.Constant(11)
), arrayP);
var marrayP = ParameterExpression.Create(new ArrayType(TypeSignature.String, 3), "a");
cx.AddTestExpr(Expression.ArrayIndex(
marrayP,
Expression.Constant(11),
Expression.Constant(12),
Expression.Constant(13)
), marrayP);
var refP = ParameterExpression.Create(new ByReferenceType(TypeSignature.Int32), "r");
cx.AddTestExpr(refP, refP);
var myTupleP = ParameterExpression.Create(new ByReferenceType(TypeReference.FromType(typeof((int, int)))), "myTuple");
cx.AddTestExpr(Expression.FieldAccess(FieldReference.FromLambda <(int, int)>(r => r.Item1), target: myTupleP), myTupleP);
check.CheckOutput(cx);
}
public void TransdelegateFunctionConversion()
{
var predicate = TypeReference.FromType(typeof(Predicate <string>));
var predicateP = ParameterExpression.Create(predicate, "predicateP");
cx.AddTestExpr(Expression.FunctionConversion(predicateP, TypeReference.FromType(typeof(Func <string, bool>))), predicateP);
check.CheckOutput(cx);
}
public void Nullable_Read()
{
var p = ParameterExpression.Create(TypeReference.FromType(typeof(int?)), "a");
cx.AddTestExpr(ExpressionFactory.Nullable_HasValue(p), p);
cx.AddTestExpr(ExpressionFactory.Nullable_Value(p), p);
check.CheckOutput(cx);
}
public void RefReturnCondition()
{
var refP1 = ParameterExpression.Create(new ByReferenceType(TypeSignature.Int32), "r1");
var refP2 = ParameterExpression.Create(new ByReferenceType(TypeSignature.Int32), "r2");
cx.AddTestExpr(refP1, refP1);
cx.AddTestExpr(Expression.Conditional(pBool1, refP1, refP2), refP1, refP2, pBool1);
check.CheckOutput(cx);
}
public void NameSanitization()
{
var stringT = TypeReference.FromType(typeof(string));
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
cx.AddType(TypeDef.Empty(type).AddMember(
// Should be renamed, there is collision with virtual object.Equals
new FieldDef(new FieldSignature(type, "Equals", Accessibility.APublic, stringT, false, true))
));
var type2 = TypeSignature.Class("MyType2", ns, Accessibility.APublic);
cx.AddType(TypeDef.Empty(type2).AddMember(
// OK, no collision here
new MethodDef(
MethodSignature.Instance("Equals", type2, Accessibility.APublic, TypeSignature.Boolean),
ImmutableArray.Create(ParameterExpression.CreateThisParam(type2)),
Expression.Constant(true)
)
));
var type3 = TypeSignature.Class("MyType3", ns, Accessibility.APublic);
cx.AddType(TypeDef.Empty(type3).AddMember(
// Should be renamed
new MethodDef(
MethodSignature.Instance("Equals", type3, Accessibility.APublic, TypeSignature.Boolean, new MethodParameter(TypeSignature.Object, "obj2")),
ImmutableArray.Create(ParameterExpression.CreateThisParam(type3), ParameterExpression.Create(TypeSignature.Object, "obj2")),
Expression.Constant(true)
)
));
var type4 = TypeSignature.Class("MyType4", ns, Accessibility.APublic);
cx.AddType(TypeDef.Empty(type4).AddMember(
// Should be renamed
new MethodDef(
MethodSignature.Static("Equals", type4, Accessibility.APublic, TypeSignature.Boolean, new MethodParameter(TypeSignature.Object, "obj2")),
ImmutableArray.Create(ParameterExpression.Create(TypeSignature.Object, "obj2")),
Expression.Constant(true)
)
));
var type5 = TypeSignature.Class("MyType5", ns, Accessibility.APublic);
cx.AddType(TypeDef.Empty(type5).AddMember(
// OK, this is override
new MethodDef(
MethodSignature.Instance("Equals", type5, Accessibility.APublic, TypeSignature.Boolean, new MethodParameter(TypeSignature.Object, "obj2")).With(isOverride: true, isVirtual: true),
ImmutableArray.Create(ParameterExpression.CreateThisParam(type5), ParameterExpression.Create(TypeSignature.Object, "obj2")),
Expression.Constant(true)
)
));
check.CheckOutput(cx);
}
public void StructMethodCall(bool reference, bool dereference)
{
cx.AddType(MyStructWithMethod());
var thisP = ParameterExpression.Create(OptionallyReference(MyStruct, reference), "this");
var target = dereference ? Expression.Dereference(thisP) : thisP;
var body = Expression.MethodCall(MyStruct_Method, ImmutableArray <Expression> .Empty, target);
cx.AddTestExpr(body, thisP);
check.CheckOutput(cx, $"ref={reference}&deref={dereference}");
}
public void StructBoxing()
{
cx.AddType(MyStructDef);
var p = ParameterExpression.Create(MyStruct, "p");
cx.AddTestExpr(Expression.ReferenceConversion(p, TypeSignature.Object), p);
cx.AddTestExpr(Expression.MethodCall(
cx.GetMemberMethods(TypeSignature.Object.NotGeneric()).Single(m => m.Signature.Name == "GetHashCode"),
args: ImmutableArray <Expression> .Empty,
Expression.ReferenceConversion(p, TypeSignature.Object)
), p);
check.CheckOutput(cx);
}
public void StructReadonlyField()
{
var roField = new FieldSignature(MyStruct, "ROField", Accessibility.APublic, TypeSignature.Int32, false, true);
cx.AddType(MyStructDef.AddMember(new FieldDef(roField)));
var thisP = ParameterExpression.Create(TypeReference.ByReferenceType(MyStruct), "this");
var body = Expression.FieldAccess(roField, thisP).Dereference();
cx.AddTestExpr(body, thisP);
check.CheckOutput(cx);
}
public void String_Concat_Objects()
{
var pString = ParameterExpression.Create(TypeSignature.String, "s");
var pInt = ParameterExpression.Create(TypeSignature.Int64, "int");
var pIntNull = ParameterExpression.Create(TypeSignature.NullableOfT.Specialize(TypeSignature.Int64), "intn");
cx.AddTestExpr(ExpressionFactory.String_Concat());
cx.AddTestExpr(ExpressionFactory.String_Concat(pInt), pInt);
cx.AddTestExpr(ExpressionFactory.String_Concat(Expression.Constant(12), Expression.Constant("--")));
cx.AddTestExpr(ExpressionFactory.String_Concat(pInt, Expression.Constant("; "), pIntNull), pInt, pIntNull);
check.CheckOutput(cx);
}
public void String_Concat()
{
var pString = ParameterExpression.Create(TypeSignature.String, "s");
cx.AddTestExpr(ExpressionFactory.String_Concat());
cx.AddTestExpr(ExpressionFactory.String_Concat(pString), pString);
cx.AddTestExpr(ExpressionFactory.String_Concat(pString, pString), pString);
cx.AddTestExpr(ExpressionFactory.String_Concat(pString, Expression.Constant("; "), pString), pString);
cx.AddTestExpr(ExpressionFactory.String_Concat(pString, Expression.Constant("; "), pString, Expression.Constant("; "), pString), pString);
cx.AddTestExpr(ExpressionFactory.String_Concat(pString, Expression.Constant("; "), ExpressionFactory.String_Concat(pString, Expression.Constant("; "), pString, Expression.Constant("; "), pString), Expression.Constant("; "), pString), pString);
check.CheckOutput(cx);
}
public void GenericMethodInGenericTypes()
{
var ns = NamespaceSignature.Parse("MyNamespace");
var t1 = new GenericParameter(Guid.NewGuid(), "T1");
var t2 = new GenericParameter(Guid.NewGuid(), "T2");
var tresult = new GenericParameter(Guid.NewGuid(), "TResult");
var rootType = TypeSignature.Class("MyType", ns, Accessibility.APublic, true, false, t1);
var(f, p) = PropertyBuilders.CreateAutoProperty(rootType, "A", t1, isReadOnly: false);
var map_fn_type = new FunctionType(new [] { new MethodParameter(t1, "a") }, tresult);
var map_sgn = MethodSignature.Instance("Map", rootType, Accessibility.APublic,
rootType.Specialize(tresult),
new [] { tresult },
new MethodParameter(map_fn_type.TryGetDelegate(), "func")
);
var tmp = ParameterExpression.Create(map_sgn.ResultType, "result");
var map_def = MethodDef.Create(map_sgn, (@this, fn) =>
Expression.Block(
new [] {
tmp.Ref()
.CallMethod(p.Setter.Signature.Specialize(new TypeReference[] { tresult }, null),
fn.Read().FunctionConvert(map_fn_type).Invoke(@this.Ref().CallMethod(p.Getter.Signature.SpecializeFromDeclaringType()))
)
},
result: tmp
)
.Where(tmp, Expression.NewObject(MethodSignature.ImplicitConstructor(rootType).Specialize(new TypeReference[] { tresult }, null)))
);
var type = TypeSignature.Class("MyNestedType", rootType, Accessibility.APublic, true, false, t2);
var t3 = new GenericParameter(Guid.NewGuid(), "T3");
var method = MethodSignature.Instance(
"M", type, Accessibility.APublic,
returnType: type.Specialize(t1, t3),
typeParameters: new [] { t3 });
var td = TypeDef.Empty(type)
.AddMember(MethodDef.Create(method, @this =>
Expression.NewObject(
MethodSignature.ImplicitConstructor(type).Specialize(new TypeReference[] { t1, t3 }, null),
ImmutableArray <Expression> .Empty
)
))
;
cx.AddType(TypeDef.Empty(rootType).AddMember(td, f, p, map_def));
check.CheckOutput(cx);
}
public void StructFieldAccess(bool reference, bool dereference)
{
cx.AddType(MyStructDef);
var thisP = ParameterExpression.Create(OptionallyReference(MyStruct, reference), "this");
var target = dereference ? Expression.Dereference(thisP) : thisP;
var body =
Expression.FieldAccess(MyStruct_IntField, target)
.ReferenceAssign(Expression.Constant(0));
cx.AddTestExpr(body, thisP);
check.CheckOutput(cx, $"ref={reference}&deref={dereference}");
}
public void ArrayIndex()
{
var arrayP = ParameterExpression.Create(new ArrayType(TypeSignature.String, 1), "a");
cx.AddTestExpr(Expression.ArrayIndex(
arrayP,
Expression.Constant(11)
).Dereference(), arrayP);
cx.AddTestExpr(Expression.ArrayIndex(
arrayP,
Expression.Constant(11)
).ReferenceAssign(Expression.Constant("abc")), arrayP);
check.CheckOutput(cx);
}
public void TrivialFunctionConversions()
{
var stringFunc = new FunctionType(ImmutableArray <MethodParameter> .Empty, TypeSignature.String).TryGetDelegate();
var objectFunc = new FunctionType(ImmutableArray <MethodParameter> .Empty, TypeSignature.Object).TryGetDelegate();
var pStringFunc = ParameterExpression.Create(stringFunc, "stringFunc");
cx.AddTestExpr(Expression.ReferenceConversion(pStringFunc, objectFunc), pStringFunc);
cx.AddTestExpr(Expression.FunctionConversion(pStringFunc, objectFunc), pStringFunc);
cx.AddTestExpr(Expression.FunctionConversion(Expression.FunctionConversion(pStringFunc, new FunctionType(ImmutableArray <MethodParameter> .Empty, TypeSignature.String)), stringFunc), pStringFunc);
cx.AddTestExpr(Expression.FunctionConversion(Expression.FunctionConversion(pStringFunc, new FunctionType(ImmutableArray <MethodParameter> .Empty, TypeSignature.Object)), objectFunc), pStringFunc);
// var predicate = cx.FindType(typeof(Predicate<string>));
// var predicateP = ParameterExpression.Create(predicate, "predicateP");
// cx.AddTestExpr(Expression.FunctionConversion(predicateP, cx.FindType(typeof(Func<string, bool>))), predicateP);
check.CheckOutput(cx);
}
public void StructInterface()
{
var icloneable = TypeSignature.FromType(typeof(ICloneable));
var method = new MethodSignature(MyStruct, ImmutableArray <MethodParameter> .Empty, "Clone", TypeSignature.Object, false, Accessibility.APublic, false, false, false, false, ImmutableArray <GenericParameter> .Empty);
var thisP = ParameterExpression.CreateThisParam(method);
var methodDef = new MethodDef(method, ImmutableArray.Create(thisP), Expression.ReferenceConversion(thisP, TypeSignature.Object));
cx.AddType(MyStructDef.AddMember(methodDef).AddImplements(new SpecializedType(icloneable, ImmutableArray <TypeReference> .Empty)));
var interfaceClone = cx.GetMemberMethods(icloneable.NotGeneric()).Single(m => m.Signature.Name == "Clone");
var p = ParameterExpression.Create(MyStruct, "p");
cx.AddTestExpr(Expression.MethodCall(method, ImmutableArray <Expression> .Empty, p), p);
cx.AddTestExpr(Expression.MethodCall(interfaceClone, ImmutableArray <Expression> .Empty, Expression.ReferenceConversion(p, icloneable)), p);
check.CheckOutput(cx);
}
public void LocalFunction()
{
ParameterExpression pA = ParameterExpression.Create(TypeSignature.Boolean, "a");
Expression fn2 = Expression.Function(
Expression.Conditional(pA, Expression.Constant(1), Expression.Constant(2)),
pA
);
ParameterExpression localFn2 = ParameterExpression.Create(fn2.Type(), "fn2");
cx.AddTestExpr(
Expression.Binary("+",
localFn2.Read().Invoke(Expression.Constant(true)),
localFn2.Read().Invoke(Expression.Constant(false))
)
.Where(localFn2, fn2)
);
check.CheckOutput(cx);
}
public void LocalFunction()
{
var fn1 = Expression.Function(Expression.Constant(1));
var v1 = ParameterExpression.Create(fn1.Type(), "v1");
var fn2 = Expression.Function(
Expression.Conditional(
pBool1,
Expression.ReferenceConversion(Expression.Invoke(v1, ImmutableArray <Expression> .Empty), TypeSignature.Object),
Expression.Constant <object>(null)
),
pBool1);
var v2 = ParameterExpression.Create(fn2.Type(), "v2");
cx.AddTestExpr(
Expression.LetIn(v1, fn1, Expression.LetIn(v2, fn2,
Expression.Invoke(v2, ImmutableArray.Create(Expression.Constant(true)))
)));
check.CheckOutput(cx);
}
TypeDef MyStructWithConstructor()
{
var methodSignature = MethodSignature.Constructor(MyStruct, Accessibility.APublic, new MethodParameter(GuidType, "id"), new MethodParameter(TypeSignature.Int32, "count"));
var thisP = ParameterExpression.CreateThisParam(MyStruct);
var idP = ParameterExpression.Create(GuidType, "id");
var countP = ParameterExpression.Create(TypeSignature.Int32, "count");
var method = MethodDef.Create(methodSignature, (thisP, idP, countP) =>
Expression.Block(
ImmutableArray.Create(
Expression.FieldAccess(MyStruct_GuidField, thisP).ReferenceAssign(idP),
Expression.FieldAccess(MyStruct_IntField, thisP).ReferenceAssign(countP)
),
result: Expression.Nop
)
);
return(MyStructDef.AddMember(method));
}
public void Variables()
{
var myVar = ParameterExpression.Create(TypeSignature.Int32, "myVar");
cx.AddTestExpr(Expression.LetIn(
myVar, Expression.Constant(42),
target: Expression.Binary("+", myVar, myVar)
));
var mutableVar = ParameterExpression.CreateMutable(TypeSignature.Int32, "mutableVar");
cx.AddTestExpr(Expression.LetIn(
mutableVar, Expression.Constant(42),
target: Expression.Binary("+",
mutableVar,
new [] {
mutableVar.Assign(Expression.Constant(30))
}.ToBlock(mutableVar)
)
));
var declaringType = TypeSignature.StaticClass("TestClass", NamespaceSignature.Parse("NS"), Accessibility.APublic);
var method = MethodSignature.Static(
"M",
declaringType,
Accessibility.APublic,
TypeSignature.Int32,
new MethodParameter(TypeSignature.Int32, "a"));
var argA = ParameterExpression.CreateMutable(TypeSignature.Int32, "a");
var body = new [] {
argA.Assign(Expression.Binary("+", argA, Expression.Constant(1)))
}.ToBlock(result: argA);
var methodDef = new MethodDef(method, new [] { argA }, body);
cx.AddType(TypeDef.Empty(declaringType).AddMember(methodDef));
check.CheckOutput(cx);
}
public void Functions()
{
// parameterless `() => 1`
Expression fn1 = Expression.Function(Expression.Constant(1));
// (bool a) => a ? 1 : 2
ParameterExpression pA = ParameterExpression.Create(TypeSignature.Boolean, "a");
Expression fn2 = Expression.Function(
Expression.Conditional(pA, Expression.Constant(1), Expression.Constant(2)),
pA
);
cx.AddTestExpr(fn1.Invoke());
cx.AddTestExpr(fn2.Invoke(Expression.Constant(true)));
var func = TypeReference.FromType(typeof(Func <bool, int>));
cx.AddTestExpr(fn2.FunctionConvert(func));
check.CheckOutput(cx);
}
public void GenericClass()
{
var paramT = GenericParameter.Create("T");
var myContainerSgn = TypeSignature.Class(
"MyContainer",
NamespaceSignature.Parse("NS"),
Accessibility.APublic,
genericParameters: new [] { paramT }
);
var(item_field, item_prop) = PropertyBuilders.CreateAutoProperty(
myContainerSgn,
name: "Item",
propertyType: paramT,
isReadOnly: false
);
var listType = TypeSignature.FromType(typeof(List <>))
.Specialize(paramT);
var toListSgn = MethodSignature.Instance(
"ToList",
myContainerSgn,
Accessibility.APublic,
returnType: listType
);
var toListDef = MethodDef.Create(toListSgn, thisParam => {
var resultVar = ParameterExpression.Create(listType, "result");
var listCtor = MethodReference.FromLambda(() => new List <int>())
.Signature
.Specialize(paramT);
var listAdd = MethodReference.FromLambda <List <int> >(l => l.Add(0))
.Signature
.Specialize(paramT);
return(Expression.LetIn(
// result = new List<T>()
resultVar, Expression.NewObject(listCtor),
new [] {
// result.Add(this.Item)
resultVar.Read().CallMethod(listAdd,
thisParam.Read().ReadField(item_field.Signature.SpecializeFromDeclaringType())
)
}.ToBlock(resultVar)
));
});
var copyFromSgn = MethodSignature.Instance(
"CopyFrom",
myContainerSgn,
Accessibility.APublic,
returnType: TypeSignature.Void,
new MethodParameter(
myContainerSgn.SpecializeByItself(),
"other"
)
);
var copyFromDef = MethodDef.Create(copyFromSgn, (thisParam, otherParam) => {
var field = item_field.Signature.SpecializeFromDeclaringType();
return(thisParam.Read().AssignField(
field,
otherParam.Read().ReadField(field)
));
});
var myContainerDef =
TypeDef.Empty(myContainerSgn)
.AddMember(item_field, item_prop, toListDef, copyFromDef);
cx.AddType(myContainerDef);
check.CheckOutput(cx);
}