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 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 Interface()
{
var type = TypeSignature.Interface("MyInterface", ns, Accessibility.APublic);
var method = MethodSignature.Instance("MyMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.String, "myParameter"));
var property = PropertySignature.Create("MyProperty", type, TypeSignature.Boolean, Accessibility.APublic, null);
var typeDef = TypeDef.Empty(type)
.AddMember(MethodDef.InterfaceDef(method))
.AddMember(PropertyDef.InterfaceDef(property));
cx.AddType(typeDef);
check.CheckOutput(cx);
}
public void ParameterDefaultValues()
{
var type = TypeSignature.Interface("MyInterface2", ns, Accessibility.APublic);
var method1 = MethodSignature.Instance("StringMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.String, "myParameter").WithDefault("default value"));
var method2 = MethodSignature.Instance("ValueTypeMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.FromType(typeof(Guid)), "myParameter").WithDefault(null));
var typeDef = TypeDef.Empty(type)
.AddMember(MethodDef.InterfaceDef(method1))
.AddMember(MethodDef.InterfaceDef(method2));
cx.AddType(typeDef);
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);
}
