public void TestCanEmit_FunctionAssignmentToFunctorWithoutArgs()
{
var voidType = assemblyEmitter.TypeSystem.Void;
var targetMethod = new MethodEmitter(typeEmitter, "TargetMethod", voidType);
targetMethod.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
CallConsoleWriteLine(new LiteralNode(assemblyEmitter.TypeSystem.String, "TargetMethod was called"))
}
});
var functorType = AssemblyRegistry.GetFunctorType(assemblyEmitter, targetMethod.Get());
var field = new FieldDefinition("myFunction", FieldAttributes.Public, functorType);
var initializer = new FunctionNode()
{
Method = targetMethod.Get(),
ObjectInstance = new ThisNode()
{
ExpressionReturnType = typeEmitter.Get(assemblyEmitter)
},
ExpressionReturnType = functorType
};
typeEmitter.AddField(field);
typeEmitter.AddFieldInitializer(field, initializer);
BodyCodeBlock = new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new MethodCallNode()
{
ExpressionReturnType = voidType,
Function = new FieldNode()
{
Field = field,
ObjectInstance = ConstructTypeEmitterInstance()
},
Args = new IExpressionNode[0]
}
}
};
ExpectedOutput = "TargetMethod was called";
AssertSuccessByExecution();
}
public void TestCanEmit_InstancePropertyInitializer()
{
var stringType = assemblyEmitter.TypeSystem.String;
var voidType = assemblyEmitter.TypeSystem.Void;
var initializer = new LiteralNode(stringType, "aaa");
var backingField = new FieldDefinition("testProperty_backingField", FieldAttributes.Private, stringType);
var setter = new MethodEmitter(typeEmitter, "set_testProperty", voidType, MethodAttributes.Public);
var value = new ParameterDefinition("value", ParameterAttributes.None, stringType);
var setterBody = new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new FieldNode()
{
ObjectInstance = new ThisNode()
{
ExpressionReturnType = backingField.DeclaringType
},
Field = backingField
},
RightOperand = new ParameterNode(value)
}
}
};
setter.AddArgument(value);
setter.ParseTree(setterBody);
var property = new PropertyDefinition("testProperty", PropertyAttributes.None, stringType);
property.SetMethod = (MethodDefinition)setter.Get();
typeEmitter.AddField(backingField);
typeEmitter.AddProperty(property, initializer);
var loadFieldExpression = new FieldNode()
{
ObjectInstance = ConstructTypeEmitterInstance(),
Field = backingField
};
GenerateBodyToOutputExpression(loadFieldExpression);
ExpectedOutput = "aaa";
AssertSuccessByExecution();
}
public void TestCanEmit_FunctionAssignmentToDelegate()
{
var voidType = assemblyEmitter.TypeSystem.Void;
var targetMethod = new MethodEmitter(typeEmitter, "TargetMethod", voidType, MethodAttributes.Private | MethodAttributes.Static);
targetMethod.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
CallConsoleWriteLine(new LiteralNode(assemblyEmitter.TypeSystem.String, "Inside target method"))
}
});
var declaringType = (TypeDefinition)typeEmitter.Get(assemblyEmitter);
var delegateType = DelegateEmitter.Create(assemblyEmitter, "MyDelegate", declaringType, voidType, new TypeReference[0]);
declaringType.NestedTypes.Add(delegateType);
var delegateField = new FieldDefinition("myDelegate", FieldAttributes.Public | FieldAttributes.Static, delegateType);
typeEmitter.AddField(delegateField);
BodyCodeBlock = new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new FieldNode(delegateField),
RightOperand = new FunctionNode()
{
ExpressionReturnType = delegateType,
Method = targetMethod.Get()
}
},
new MethodCallNode()
{
ExpressionReturnType = voidType,
Function = new FieldNode(delegateField),
Args = new IExpressionNode[0]
}
}
};
ExpectedOutput = "Inside target method";
AssertSuccessByExecution();
}
internal MethodReference EmitMethodToOutputArgs(IExpressionNode returnValue, params TypeReference[] args)
{
var returnType = returnValue != null ? returnValue.ExpressionReturnType : assemblyEmitter.TypeSystem.Void;
var targetMethod = new MethodEmitter(typeEmitter, "TargetMethod", returnType, MethodAttributes.Static | MethodAttributes.Private);
var nodes = new List <IParserNode>();
if (args.Length > 0)
{
var consoleWriteLineArgs = new List <IExpressionNode>();
var parameters = args.Select(a => targetMethod.AddArgument(new ParameterDefinition(a))).ToArray();
var formatString = new StringBuilder();
for (int i = 0; i < parameters.Length; i++)
{
formatString.Append(string.Format("{{{0}}}", i));
if (i != parameters.Length - 1)
{
formatString.Append("\r\n");
}
}
consoleWriteLineArgs.Add(new LiteralNode(assemblyEmitter.TypeSystem.String, formatString.ToString()));
consoleWriteLineArgs.AddRange(parameters.Select(p => new ParameterNode(p)));
nodes.Add(CallConsoleWriteLine(consoleWriteLineArgs.ToArray()));
}
if (returnValue != null)
{
nodes.Add(new ReturnNode()
{
Expression = returnValue
});
}
targetMethod.ParseTree(new CodeBlockNode()
{
Nodes = nodes
});
return(targetMethod.Get());
}
public void TestCanEmit_StaticPropertyInitializer()
{
var boolType = assemblyEmitter.TypeSystem.Boolean;
var voidType = assemblyEmitter.TypeSystem.Void;
var initializer = new LiteralNode(boolType, true);
var backingField = new FieldDefinition("testProperty_backingField", FieldAttributes.Private | FieldAttributes.Static, boolType);
var setter = new MethodEmitter(typeEmitter, "set_testProperty", voidType, MethodAttributes.Public | MethodAttributes.Static);
var value = new ParameterDefinition("value", ParameterAttributes.None, boolType);
var setterBody = new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new FieldNode(backingField),
RightOperand = new ParameterNode(value)
}
}
};
setter.AddArgument(value);
setter.ParseTree(setterBody);
var property = new PropertyDefinition("testProperty", PropertyAttributes.None, boolType);
property.SetMethod = (MethodDefinition)setter.Get();
typeEmitter.AddField(backingField);
typeEmitter.AddProperty(property, initializer);
GenerateBodyToOutputExpression(new FieldNode(backingField));
ExpectedOutput = true.ToString();
AssertSuccessByExecution();
}
public void Test_FunctorsGetIncludedToAssembly()
{
var intType = assemblyEmitter.TypeSystem.Int32;
var stringType = assemblyEmitter.TypeSystem.String;
var floatType = assemblyEmitter.TypeSystem.Single;
var boolType = assemblyEmitter.TypeSystem.Boolean;
var functor1 = GetFunctorType(intType, stringType, floatType, boolType);
var functor2 = GetFunctorType(stringType, intType, floatType, boolType);
var functor3 = GetFunctorType(stringType, floatType, intType, boolType);
var functor4 = GetFunctorType(stringType, floatType, boolType, intType);
var functor5 = GetFunctorType(stringType, boolType, floatType, intType);
var method1 = new MethodEmitter(typeEmitter, "ReturnsFunctor", functor1, MethodAttributes.Static | MethodAttributes.Private);
method1.ParseTree(new CodeBlockNode()
{
Nodes = new IParserNode[]
{
CallConsoleWriteLine(new LiteralNode(stringType, "Inside method that returns functor.")),
new ReturnNode()
{
Expression = new NullNode()
}
}
});
var field = new FieldDefinition("functorField", FieldAttributes.Static | FieldAttributes.Private, functor2);
typeEmitter.AddField(field);
var method2 = new MethodEmitter(typeEmitter, "TakesFunctorAsArgument", assemblyEmitter.TypeSystem.Void, MethodAttributes.Static | MethodAttributes.Private);
var parameter = method2.AddArgument(functor3, "param");
method2.ParseTree(new CodeBlockNode()
{
Nodes = new IParserNode[]
{
CallConsoleWriteLine(new LiteralNode(stringType, "Inside method that takes functor parameter. Its value: {0}."), new ParameterNode(parameter))
}
});
var localVariable = new VariableDefinition(functor4);
BodyCodeBlock = new CodeBlockNode()
{
Nodes = new IParserNode[]
{
new SymbolDeclarationNode()
{
Variable = localVariable
},
CallConsoleWriteLine(new LiteralNode(stringType, "Value of functor field: {0}."), new FieldNode(field)),
CallConsoleWriteLine(new LiteralNode(stringType, "Value of functor local variable: {0}."), new LocalVariableNode(localVariable)),
CallConsoleWriteLine(new LiteralNode(stringType, "Value of null cast to functor: {0}."), new CastNode(new NullNode(), functor5)),
new MethodCallNode()
{
Function = new FunctionNode()
{
Method = method1.Get()
},
Args = new IExpressionNode[0]
},
new MethodCallNode()
{
Function = new FunctionNode()
{
Method = method2.Get()
},
Args = new IExpressionNode[]
{
new NullNode()
}
}
}
};
ExpectedOutput = string.Format("Value of functor field: .{0}Value of functor local variable: .{0}Value of null cast to functor: .{0}Inside method that returns functor.{0}Inside method that takes functor parameter. Its value: .", Environment.NewLine);
AssertSuccessByExecution();
}
public void TestCanEmit_FunctorPropertyAssignmentToDelegate()
{
const int kArg1 = 485613;
const string kArg2 = "FASD4FSAD14asdf";
var intType = assemblyEmitter.TypeSystem.Int32;
var stringType = assemblyEmitter.TypeSystem.String;
var voidType = assemblyEmitter.TypeSystem.Void;
var arguments = new TypeReference[]
{
intType,
stringType
};
#region Functor Property Setup
var functorType = AssemblyRegistry.GetFunctorType(assemblyEmitter, voidType, arguments);
var functorField = new FieldDefinition("myFunction_BackingField", FieldAttributes.Public | FieldAttributes.Static, functorType);
typeEmitter.AddField(functorField);
#region Setter
var functorSetter = new MethodEmitter(typeEmitter, "set_MyFunction", voidType, MethodAttributes.Public | MethodAttributes.Static);
var functorSetterArgument = functorSetter.AddArgument(functorType, "value");
functorSetter.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new FieldNode(functorField),
RightOperand = new ParameterNode(functorSetterArgument)
}
}
});
#endregion
#region Getter
var functorGetter = new MethodEmitter(typeEmitter, "get_MyFunction", functorType, MethodAttributes.Public | MethodAttributes.Static);
functorGetter.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new ReturnNode()
{
Expression = new FieldNode(functorField)
}
}
});
#endregion
var functorProperty = new PropertyDefinition("MyFunction", PropertyAttributes.None, functorType);
functorProperty.SetMethod = functorSetter.Get().Resolve();
functorProperty.GetMethod = functorGetter.Get().Resolve();
typeEmitter.AddProperty(functorProperty);
#endregion
#region Delegate Property setup
var declaringType = (TypeDefinition)typeEmitter.Get(assemblyEmitter);
var delegateType = DelegateEmitter.Create(assemblyEmitter, declaringType, voidType, arguments);
declaringType.NestedTypes.Add(delegateType);
var delegateField = new FieldDefinition("myDelegate_BackingField", FieldAttributes.Private | FieldAttributes.Static, delegateType);
typeEmitter.AddField(delegateField);
#region Setter
var delegateSetter = new MethodEmitter(typeEmitter, "set_MyDelegate", voidType, MethodAttributes.Public | MethodAttributes.Static);
var delegateSetterArgument = delegateSetter.AddArgument(delegateType, "value");
delegateSetter.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new FieldNode(delegateField),
RightOperand = new ParameterNode(delegateSetterArgument)
}
}
});
#endregion
#region Getter
var delegateGetter = new MethodEmitter(typeEmitter, "get_MyDelegate", delegateType, MethodAttributes.Public | MethodAttributes.Static);
delegateGetter.ParseTree(new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new ReturnNode()
{
Expression = new FieldNode(delegateField)
}
}
});
#endregion
var delegateProperty = new PropertyDefinition("MyDelegate", PropertyAttributes.None, delegateType);
delegateProperty.SetMethod = delegateSetter.Get().Resolve();
delegateProperty.GetMethod = delegateGetter.Get().Resolve();
typeEmitter.AddProperty(delegateProperty);
#endregion
BodyCodeBlock = new CodeBlockNode()
{
Nodes = new List <IParserNode>()
{
new AssignmentOperatorNode()
{
LeftOperand = new PropertyNode(assemblyEmitter, functorProperty),
RightOperand = new FunctionNode()
{
ExpressionReturnType = functorType,
Method = EmitMethodToOutputArgs(null, arguments)
}
},
new AssignmentOperatorNode()
{
LeftOperand = new PropertyNode(assemblyEmitter, delegateProperty),
RightOperand = new PropertyNode(assemblyEmitter, functorProperty)
},
new MethodCallNode()
{
ExpressionReturnType = voidType,
Function = new PropertyNode(assemblyEmitter, delegateProperty),
Args = new IExpressionNode[]
{
new LiteralNode(intType, kArg1),
new LiteralNode(stringType, kArg2)
}
}
}
};
ExpectedOutput = string.Format("{0}\r\n{1}", kArg1, kArg2);
AssertSuccessByExecution();
}
