public void Overrides(bool isInterface, bool isSealed, bool isAbstract)
{
var mGenerics = Enumerable.Range(0, 2).Select(i => GenericParameter.Create("U" + i)).ToArray();
var baseType = isInterface ? TypeSignature.Interface("Base", ns, Accessibility.APublic)
: TypeSignature.Class("BaseC", ns, Accessibility.APublic, isAbstract: true);
var baseMethod1 = MethodSignature.Abstract("M1", baseType, isInterface ? Accessibility.APublic : Accessibility.AProtected, TypeSignature.Object).With(isAbstract: isInterface);
var baseMethod2 = MethodSignature.Abstract("M2", baseType, Accessibility.APublic, mGenerics[0], new MethodParameter(mGenerics[1], "a")).With(typeParameters: mGenerics.ToImmutableArray());
var baseProperty = PropertySignature.Abstract("P1", baseType, TypeSignature.Boolean, Accessibility.APublic, null);
cx.AddType(TypeDef.Empty(baseType).AddMember(
isInterface ? MethodDef.InterfaceDef(baseMethod1) : MethodDef.Create(baseMethod1, _ => Expression.Constant <object>(null)),
MethodDef.InterfaceDef(baseMethod2),
PropertyDef.InterfaceDef(baseProperty)
));
var type = TypeSignature.Class("C", ns, Accessibility.APublic, canOverride: !isSealed, isAbstract: isAbstract);
var method1 = MethodSignature.Override(type, baseMethod1, isAbstract: isAbstract);
var method2 = MethodSignature.Override(type, baseMethod2);
var property = PropertySignature.Override(type, baseProperty);
cx.AddType(TypeDef.Empty(type, isInterface ? null : baseType.Specialize())
.AddImplements(isInterface ? new [] { baseType.Specialize() } : new SpecializedType[0])
.AddMember(
isAbstract ? MethodDef.InterfaceDef(method1) : MethodDef.Create(method1, _ => Expression.Constant(1).Box()),
MethodDef.Create(method2, (_, __) => Expression.Default(method2.TypeParameters[0])),
PropertyDef.Create(property, @this => Expression.Default(property.Type))
));
check.CheckOutput(cx, $"ifc({isInterface})-sealed({isSealed})-abstract({isAbstract})");
}
public void HelloWorld()
{
// declare
// namespace MyApp.HelloWorld {
var ns = NamespaceSignature.Parse("MyApp.HelloWorld");
// public class Program {
var programType = TypeSignature.Class("Program", ns, Accessibility.APublic);
// public static int Main() {
var mainMethod = MethodSignature.Static("Main", programType, Accessibility.APublic, returnType: TypeSignature.Int32);
// get the Console.WriteLine reference
var writeLineRef = MethodReference.FromLambda(() => Console.WriteLine(""));
var body = new [] {
Expression.StaticMethodCall(writeLineRef, Expression.Constant("Hello world!"))
}.ToBlock(
result: Expression.Constant(0)
);
var type = TypeDef.Empty(programType).AddMember(
MethodDef.Create(mainMethod, body)
);
var cx = MetadataContext.Create();
cx.AddType(type);
var csharp = cx.EmitToString();
check.CheckString(csharp, fileExtension: "cs");
}
public void OneEmptyType()
{
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var typeDef = TypeDef.Empty(type);
cx.AddType(typeDef);
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 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 static void AddTestExpr(this MetadataContext cx, Expression expr, params ParameterExpression[] parameters)
{
var typeCount = cx.DefinedTypes.Count;
var name = typeCount < 15 ? ((char)('C' + typeCount)).ToString() : "C" + typeCount;
var ns = ((TypeOrNamespace.NamespaceSignatureCase)cx.DefinedTypes.FirstOrDefault()?.Signature.Parent)?.Item ??
new NamespaceSignature("NS", NamespaceSignature.Global);
var type = TypeSignature.Class(name, ns, Accessibility.APublic);
var method = new MethodSignature(type, parameters.Select(p => new MethodParameter(p.Type, p.Name)).ToImmutableArray(), "M", expr.Type(), true, Accessibility.APublic, false, false, false, false, ImmutableArray <GenericParameter> .Empty);
var methodDef = new MethodDef(method, parameters.ToImmutableArray(), expr);
var typeDef = TypeDef.Empty(type).With(members: ImmutableArray.Create <MemberDef>(methodDef));
cx.AddType(typeDef);
cx.CommitWaitingTypes();
}
public void AutoProperties()
{
var ns = NamespaceSignature.Parse("MyNamespace");
var t1 = new GenericParameter(Guid.NewGuid(), "T1");
var t2 = new GenericParameter(Guid.NewGuid(), "T2");
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic, true, false, t1, t2);
var td = TypeDef.Empty(type)
.AddAutoProperty("A", t1, Accessibility.APublic)
.AddAutoProperty("B", t2, Accessibility.APublic, isStatic: true)
.AddAutoProperty("C", TypeSignature.FromType(typeof(Dictionary <,>)).Specialize(t1, t2), Accessibility.APublic, isStatic: true, isReadOnly: false)
.AddAutoProperty("D", TypeReference.Tuple(t1, TypeSignature.String, t2), Accessibility.APublic, isReadOnly: false)
;
cx.AddType(td);
check.CheckOutput(cx);
}
public void Doccomments()
{
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var td = TypeDef.Empty(type)
.With(doccomment: new XmlComment("<summary> My type </summary>"))
.AddAutoProperty("A", TypeSignature.String, Accessibility.APublic, doccomment: new XmlComment("<summary> My property </summary>"))
;
var fieldSgn = new FieldSignature(type, "Field", Accessibility.AInternal, TypeSignature.Int16, false, false);
td = td.AddMember(
new FieldDef(fieldSgn, new XmlComment("<summary> My field </summary>"))
);
cx.AddType(td);
check.CheckOutput(cx);
}
public void StandardProperties()
{
// TODO: remove those CompilerGenerated attributes
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var prop = PropertySignature.Create("A", type, TypeSignature.String, Accessibility.APublic, Accessibility.AProtected);
var td = TypeDef.Empty(type).AddMember(
new PropertyDef(prop,
getter: MethodDef.Create(prop.Getter, thisP => Expression.Constant("abcd")),
setter: MethodDef.Create(prop.Setter, (thisP, xP) =>
Expression.While(FluentExpression.Box(thisP).CallMethod(MethodSignature.Object_Equals, Expression.Default(TypeSignature.Object)), Expression.Nop))
)
);
cx.AddType(td);
check.CheckOutput(cx);
}
public void ToStringExample()
{
var type = TypeSignature.Class("MyClass", NamespaceSignature.Parse("NS"), Accessibility.APublic);
cx.AddType(ImplementToString(
TypeDef.Empty(type)
.AddAutoProperty("A", TypeSignature.String)
.AddAutoProperty("B", TypeSignature.ValueTuple2.Specialize(TypeSignature.Boolean, TypeSignature.Boolean))
));
cx.AddType(ImplementToString(
TypeDef.Empty(type.With(name: "SecondClass"))
));
check.CheckOutput(cx);
}
public void AutoProperties()
{
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var td = TypeDef.Empty(type)
.AddAutoProperty("A", TypeSignature.String, Accessibility.APublic)
.AddAutoProperty("B", TypeSignature.String, Accessibility.APublic, isStatic: true)
.AddAutoProperty("C", TypeSignature.String, Accessibility.APublic, isStatic: true, isReadOnly: false)
.AddAutoProperty("D", TypeSignature.String, Accessibility.APublic, isReadOnly: false)
.AddAutoProperty("E", TypeSignature.TimeSpan, Accessibility.APublic)
.AddAutoProperty("F", type, Accessibility.APublic)
;
cx.AddType(td);
check.CheckOutput(cx);
check.CheckString(td.ToString());
}
public void FewFields()
{
var stringT = TypeReference.FromType(typeof(string));
var stringArr = TypeReference.FromType(typeof(string[]));
var someTuple = TypeReference.FromType(typeof((List <int>, System.Threading.Tasks.Task)));
var ns = NamespaceSignature.Parse("MyNamespace");
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var typeDef = TypeDef.Empty(type).With(members: ImmutableArray.Create <MemberDef>(
new FieldDef(new FieldSignature(type, "F1", Accessibility.APublic, stringT, false, true)),
new FieldDef(new FieldSignature(type, "F2", Accessibility.APrivate, stringArr, false, true)),
new FieldDef(new FieldSignature(type, "F3", Accessibility.AInternal, someTuple, false, true)),
new FieldDef(new FieldSignature(type, "F4", Accessibility.AProtectedInternal, stringArr, true, false))
));
cx.AddType(typeDef);
check.CheckOutput(cx);
}
public void IEquatableImplementation(bool isStruct, bool isExplicit)
{
var type = isStruct ? TypeSignature.Struct("MyType", ns, Accessibility.APublic)
: TypeSignature.Class("MyType", ns, Accessibility.APublic);
var iequatableT = TypeSignature.FromType(typeof(IEquatable <>)).Specialize(type);
var interfaceMethod = cx.GetMemberMethods(iequatableT, "Equals").Single();
var method = new MethodSignature(type, ImmutableArray.Create(new MethodParameter(type, "obj")), "Equals", TypeReference.FromType(typeof(bool)), false, isExplicit ? Accessibility.APrivate : Accessibility.APublic, false, false, false, false, ImmutableArray <GenericParameter> .Empty);
var methodDef = MethodDef.Create(method, (_thisP, _objP) => new ConstantExpression(true, TypeReference.FromType(typeof(bool))))
.AddImplements(interfaceMethod);
var typeDef = TypeDef.Empty(type).With(
implements: ImmutableArray.Create(iequatableT),
members: ImmutableArray.Create <MemberDef>(methodDef));
cx.AddType(typeDef);
check.CheckOutput(cx, $"{(isStruct ? "struct" : "class")}{(isExplicit ? "-explicit" : "")}");
}
public void NestedTypesWithInheritance()
{
var rootType = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var type1 = TypeSignature.Class("A", rootType, Accessibility.APublic);
var type2 = type1.With(name: "B");
var typeDef = TypeDef.Empty(rootType).With(members: ImmutableArray.Create <MemberDef>(
new TypeDef(type1, null, ImmutableArray <SpecializedType> .Empty, ImmutableArray <MemberDef> .Empty),
new TypeDef(type2, new SpecializedType(type1, ImmutableArray <TypeReference> .Empty), ImmutableArray <SpecializedType> .Empty, ImmutableArray <MemberDef> .Empty)
));
cx.AddType(typeDef);
var rootType2 = typeDef.Signature.With(name: "MyType2");
cx.AddType(typeDef.With(
signature: rootType2,
extends: new SpecializedType(type2, ImmutableArray <TypeReference> .Empty),
members: typeDef.Members.OfType <TypeDef>().Select(m => m.With(signature: m.Signature.With(parent: TypeOrNamespace.TypeSignature(rootType2)))).ToImmutableArray <MemberDef>()
));
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);
}
