private Expression InvokeMethod()
{
var instanceMember = invocationStatement.Method as InstanceMethodMemberStatement;
BindingFlags bindingFlags = instanceMember == null ? BindingFlags.Static : BindingFlags.Instance;
bindingFlags |= invocationStatement.Method.AccessModifier == HotReloading.Core.AccessModifier.Public ?
BindingFlags.Public : BindingFlags.NonPublic;
Type declareType = (Type)invocationStatement.Method.ParentType;
var parameterTypes = invocationStatement.ParametersSignature.Select(x => (Type)x).ToArray();
var methodInfo =
declareType.GetMethod(invocationStatement.Method.Name,
bindingFlags, Type.DefaultBinder, parameterTypes, null);
var arguments = invocationStatement.Arguments
.Select(x => expressionInterpreterHandler.GetExpression(x)).ToArray();
Expression[] convertedArguments = methodInfo.ConvertArguments(arguments);
if (instanceMember != null)
{
var caller = expressionInterpreterHandler.GetExpression(instanceMember.Parent);
return(Expression.Call(
caller,
methodInfo, convertedArguments));
}
return(Expression.Call(methodInfo, convertedArguments));
}
public Expression GetExpression()
{
var condition = expressionInterpreterHandler.GetExpression(whileStatement.Conditional);
var block = expressionInterpreterHandler.GetExpression(whileStatement.Statement);
return(CSharpExpression.While(condition, block, brk, cont));
}
public Expression GetExpression()
{
var condition = expressionInterpreterHandler.GetExpression(doWhileStatement.Conditional);
var statement = expressionInterpreterHandler.GetExpression(doWhileStatement.Statement);
return(CSharpExpression.Do(statement, condition, brk, cont));
}
public Expression GetExpression()
{
if (arrayCreationStatement.Initializers == null)
{
var bounds = arrayCreationStatement.Bounds.Select(x => expressionInterpreterHandler.GetExpression(x)
).ToList();
return(Expression.NewArrayBounds(arrayCreationStatement.Type, bounds));
}
else
{
var bounds = arrayCreationStatement.Bounds.Cast <ConstantStatement>().Select(x =>
{
return(Convert.ToInt32(x.Value));
}).ToArray();
var initializers = arrayCreationStatement.Initializers.Select(x =>
expressionInterpreterHandler.GetExpression(x));
if (bounds.Length == 1)
{
return(Expression.NewArrayInit(arrayCreationStatement.Type, initializers));
}
return(CSharpExpression.NewMultidimensionalArrayInit(arrayCreationStatement.Type, bounds, initializers));
}
}
public Expression GetExpression()
{
var left = expressionInterpreterHandler.GetExpression(objectEqualStatement.Left);
var right = expressionInterpreterHandler.GetExpression(objectEqualStatement.Right);
var equalMethod = typeof(object).GetMethod("Equals", new Type[] { typeof(object), typeof(object) });
return(Expression.Call(equalMethod, left, right));
}
public Expression GetExpression()
{
var initializers = forStatement.Initializers.Select(x => expressionInterpreterHandler.GetExpression(x)).Cast <BinaryExpression>().ToList();
var condition = forStatement.Condition == null ? null : expressionInterpreterHandler.GetExpression(forStatement.Condition);
var iterators = forStatement.Iterators.Select(x => expressionInterpreterHandler.GetExpression(x)).ToList();
var statement = expressionInterpreterHandler.GetExpression(forStatement.Statement);
return(CSharpExpression.For(initializers, condition, iterators, statement, brk, cont));
}
public Expression GetExpression()
{
var variable = expressionInterpreterHandler.GetExpression(forEachStatement.Variable) as ParameterExpression;
var collection = expressionInterpreterHandler.GetExpression(forEachStatement.Collection);
scopedLocalVariable.Add(variable);
var body = expressionInterpreterHandler.GetExpression(forEachStatement.Body);
scopedLocalVariable.Remove(variable);
return(CSharpExpression.ForEach(variable, collection, body, brk, cont));
}
public Expression GetExpression()
{
var condition = expressionInterpreterHandler.GetExpression(ifStatement.Condition);
var ifTrue = expressionInterpreterHandler.GetExpression(ifStatement.IfTrue);
if (ifStatement.IfFalse == null)
{
return(Expression.IfThen(condition, ifTrue));
}
{
var ifFalse = expressionInterpreterHandler.GetExpression(ifStatement.IfFalse);
return(Expression.IfThenElse(condition, ifTrue, ifFalse));
}
}
public Expression GetExpression()
{
var left = binaryStatement.Left;
if (left is DelegateIdentifierStatement delegateIdentifier)
{
left = delegateIdentifier.Target;
}
if (left is StaticEventMemberStatement ||
left is InstanceEventMemberStatement)
{
return(AssignEventExpression(left));
}
return(GetExpression(expressionInterpreterHandler.GetExpression(binaryStatement.Left),
expressionInterpreterHandler.GetExpression(binaryStatement.Right), binaryStatement.Operand));
}
public Expression GetExpression()
{
var parent = expressionInterpreterHandler.GetExpression(arrayAccessStatement.Array);
var indexes = arrayAccessStatement.Indexes.Select(x => expressionInterpreterHandler.GetExpression(x));
var parentType = (Type)arrayAccessStatement.Type;
if (parentType.IsArray)
{
return(Expression.ArrayAccess(parent, indexes));
}
var indexer = parentType.GetProperties().First(x => x.GetIndexParameters().Length == indexes.Count());
return(Expression.MakeIndex(parent, indexer, indexes));
}
public Expression GetExpression()
{
var varDeclarationStatements = block.Statements.OfType <LocalVariableDeclaration>();
var varDeclarationExpresions = varDeclarationStatements.Select(x =>
interpreterHandler.GetExpression(x)).Cast <ParameterExpression>().ToList();
scopedLocalVariable.AddRange(varDeclarationExpresions);
var statementExpressions = block.Statements
.Except(varDeclarationStatements)
.Select(x => interpreterHandler.GetExpression(x)).ToList();
scopedLocalVariable.RemoveAll(x => varDeclarationExpresions.Contains(x));
return(Expression.Block(varDeclarationExpresions, statementExpressions));
}
public Expression GetExpression()
{
Type declareType = (Type)delegateInvocationStatement.Delegate.Type;
var methodInfo =
declareType.GetMethod("Invoke");
var arguments = delegateInvocationStatement.Arguments.Select(x =>
expressionInterpreterHandler.GetExpression(x)).ToArray();
Expression[] convertedArguments = methodInfo.ConvertArguments(arguments);
var caller = expressionInterpreterHandler.GetExpression(delegateInvocationStatement.Delegate.Target);
return(Expression.Call(
caller,
methodInfo, convertedArguments));
}
public Expression GetExpression()
{
var parentExpression = interpreterHandler.GetExpression(statement.Parent);
var property = parentExpression.Type.GetMostSuitableProperty(statement.Name);
return(Expression.Property(parentExpression,
property));
}
public Expression GetExpression()
{
switch (unaryStatement.Operator)
{
case UnaryOperand.PostDecrementAssign:
return(Expression.PostDecrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PostIncrementAssign:
return(Expression.PostIncrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PreDecrementAssign:
return(Expression.PreDecrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PreIncrementAssign:
return(Expression.PreIncrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.Not:
return(Expression.Not(expressionInterpreterHandler.
GetExpression(
unaryStatement.Operand)));
case UnaryOperand.OnesComplement:
var operand = expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand);
if (operand.Type.IsEnum)
{
var operand1 = Expression.Convert(operand, Enum.GetUnderlyingType(operand.Type));
return(Expression.OnesComplement(operand1));
}
return(Expression.OnesComplement(operand));
case UnaryOperand.UnaryMinus:
return(Expression.Negate(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.UnaryPlus:
return(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand));
default:
throw new NotSupportedException(unaryStatement.Operand + " is not suppoted unary statement");
}
}
public Expression GetExpression()
{
ParameterExpression variable = null;
if (usingStatement.Variable != null)
{
variable = expressionInterpreterHandler.GetExpression(usingStatement.Variable) as ParameterExpression;
scopedLocalVariable.Add(variable);
}
var resource = expressionInterpreterHandler.GetExpression(usingStatement.Resource);
var body = expressionInterpreterHandler.GetExpression(usingStatement.Body);
if (variable != null)
{
scopedLocalVariable.Remove(variable);
return(CSharpExpression.Using(variable, resource, body));
}
return(CSharpExpression.Using(resource, body));
}
public Expression GetExpression()
{
var parent = interpreterHandler.GetExpression(statement.Parent);
var bindingFlags = BindingFlags.Instance;
bindingFlags |= statement.AccessModifier == HotReloading.Core.AccessModifier.Public ?
BindingFlags.Public : BindingFlags.NonPublic;
var field = parent.Type.GetField(statement.Name, bindingFlags);
return(Expression.Field(parent, field));
}
public Expression GetExpression()
{
Expression condition = expressionInterpreterHandler.GetExpression(conditionalStatement.Condition);
Expression ifTrue = expressionInterpreterHandler.GetExpression(conditionalStatement.IfTrue);
Expression ifFalse = expressionInterpreterHandler.GetExpression(conditionalStatement.IfFalse);
if (ifTrue.Type != ifFalse.Type)
{
if (ifTrue.Type.IsSubclassOf(ifFalse.Type))
{
ifFalse = Expression.Convert(ifFalse, ifTrue.Type);
}
else
{
ifTrue = Expression.Convert(ifTrue, ifFalse.Type);
}
}
return(Expression.Condition(condition,
ifTrue,
ifFalse));
}
public Expression GetExpression()
{
var bindingFlags = BindingFlags.Instance;
bindingFlags |= BindingFlags.NonPublic;
var fieldInfo = ((Type)instanceEventMemberStatement.ParentType).GetField(instanceEventMemberStatement.Name,
bindingFlags);
var parent = expressionInterpreterHandler.GetExpression(instanceEventMemberStatement.Parent);
return(Expression.Field(parent, fieldInfo));
}
public Expression GetExpression()
{
var parentExpression = interpreterHandler.GetExpression(statement.Parent);
var bindingFlags = BindingFlags.Instance;
bindingFlags |= statement.AccessModifier == HotReloading.Core.AccessModifier.Public ?
BindingFlags.Public : BindingFlags.NonPublic;
var property = parentExpression.Type.GetMostSuitableProperty(statement.Name, bindingFlags);
return(Expression.Property(parentExpression,
property));
}
public Expression GetExpression()
{
var suppliedArgs = invocationStatement.Arguments;
var arguments = invocationStatement.Arguments
.Select(x => expressionInterpreterHandler.GetExpression(x)).ToArray();
var parameterTypes = invocationStatement.ParametersSignature.Select(x => (Type)x).ToArray();
var methodInfo =
((Type)invocationStatement.Method.ParentType).GetMethod(invocationStatement.Method.Name,
parameterTypes);
Expression[] convertedArguments = new Expression[arguments.Length];
for (int i = 0; i < convertedArguments.Length; i++)
{
var argument = arguments[i];
var parameter = methodInfo.GetParameters()[i];
if (parameter.ParameterType != argument.Type)
{
convertedArguments[i] = Expression.Convert(argument, parameter.ParameterType);
}
else
{
convertedArguments[i] = argument;
}
}
if (invocationStatement.Method is InstanceMethodMemberStatement instanceStatement)
{
return(Expression.Call(
expressionInterpreterHandler.GetExpression(instanceStatement.Parent),
methodInfo, convertedArguments));
}
return(Expression.Call(methodInfo, convertedArguments));
}
public Expression GetExpression()
{
var switchValue = expressionInterpreterHandler.GetExpression(switchStatement.SwitchValue);
var cases = new List <System.Linq.Expressions.SwitchCase>();
foreach (var switchCase in switchStatement.Cases)
{
var body = expressionInterpreterHandler.GetExpression(switchCase.Body);
var tests = switchCase.Tests.Select(x => expressionInterpreterHandler.GetExpression(x));
cases.Add(Expression.SwitchCase(body, tests));
}
if (switchStatement.Default != null)
{
var defaultBody = expressionInterpreterHandler.GetExpression(switchStatement.Default)
;
return(Expression.Switch(switchValue, defaultBody, cases.ToArray()));
}
return(Expression.Switch(switchValue, cases.ToArray()));
}
public Expression GetExpression()
{
var parameters = lamdaStatement.Parameters.Select(x =>
Expression.Parameter(x.Type, x.Name)).ToArray();
parameterExpressions.AddRange(parameters);
var body = expressionInterpreterHandler.GetExpression(lamdaStatement.Body);
parameterExpressions.RemoveAll(x => parameters.Any(y => y == x));
var type = (Type)lamdaStatement.Type;
var delegateType = type;
if (!type.IsSubclassOf(typeof(MulticastDelegate)))
{
delegateType = type.GenericTypeArguments.FirstOrDefault();
MethodInfo lambdaMethod;
if (lamdaStatement.IsAsync)
{
lambdaMethod = typeof(CSharpExpression).GetMethod("AsyncLambda", new Type[] { typeof(Type), typeof(Expression), typeof(ParameterExpression[]) });
}
else
{
lambdaMethod = typeof(Expression).GetMethod("Lambda", new Type[] { typeof(Type), typeof(Expression), typeof(ParameterExpression[]) });
}
return(Expression.Call(null, lambdaMethod, Expression.Constant(delegateType), Expression.Constant(body), Expression.Constant(parameters)));
}
Expression lamda;
if (lamdaStatement.IsAsync)
{
lamda = CSharpExpression.AsyncLambda(delegateType, body, parameters);
}
else
{
lamda = Expression.Lambda(delegateType, body, parameters);
}
return(lamda);
}
public Expression GetExpression()
{
if (methodPointerStatement.Method is InstanceMethodMemberStatement instanceMethodMemberStatement)
{
var createDelegateMethod = typeof(Delegate).GetMethod("CreateDelegate", new Type[] { typeof(Type), typeof(object), typeof(string) });
return(Expression.Call(null, createDelegateMethod,
Expression.Constant((Type)methodPointerStatement.Type),
expressionInterpreterHandler.GetExpression(instanceMethodMemberStatement.Parent),
Expression.Constant(instanceMethodMemberStatement.Name)
));
}
else if (methodPointerStatement.Method is StaticMethodMemberStatement staticMethodMemberStatement)
{
var createDelegateMethod = typeof(Delegate).GetMethod("CreateDelegate", new Type[] { typeof(Type), typeof(Type), typeof(string) });
return(Expression.Call(null, createDelegateMethod,
Expression.Constant((Type)methodPointerStatement.Type),
Expression.Constant((Type)staticMethodMemberStatement.ParentType),
Expression.Constant(staticMethodMemberStatement.Name)
));
}
throw new NotImplementedException("Unsupported method pointer: " + methodPointerStatement.Method.GetType().FullName);
}
public Expression GetExpression()
{
var tryBlock = tryStatement.TryBlock == null ?
null : expressionInterpreterHandler.GetExpression(tryStatement.TryBlock);
var finallyBlock = tryStatement.Finally == null ?
null : expressionInterpreterHandler.GetExpression(tryStatement.Finally);
var catches = new List <CatchBlock>();
foreach (var catchStatement in tryStatement.Catches)
{
if (catchStatement.Variable != null)
{
var variable = (ParameterExpression)expressionInterpreterHandler.GetExpression(catchStatement.Variable);
scopedLocalVariable.Add(variable);
var blockExpression = expressionInterpreterHandler.GetExpression(catchStatement.Block);
var filterExpression = catchStatement.Filter == null ?
null : expressionInterpreterHandler.GetExpression(catchStatement.Filter);
scopedLocalVariable.Remove(variable);
catches.Add(Expression.Catch(variable, blockExpression, filterExpression));
}
else
{
var catchVariableType = catchStatement.Type != null ?
(Type)catchStatement.Type : typeof(Exception);
var blockExpression = expressionInterpreterHandler.GetExpression(catchStatement.Block);
var filterExpression = catchStatement.Filter == null ?
null : expressionInterpreterHandler.GetExpression(catchStatement.Filter);
catches.Add(Expression.Catch(catchVariableType, blockExpression, filterExpression));
}
}
return(Expression.TryCatchFinally(tryBlock, finallyBlock, catches.ToArray()));
}
public Expression GetExpression()
{
switch (unaryStatement.Operator)
{
case UnaryOperand.PostDecrementAssign:
return(Expression.PostDecrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PostIncrementAssign:
return(Expression.PostIncrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PreDecrementAssign:
return(Expression.PreDecrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.PreIncrementAssign:
return(Expression.PreIncrementAssign(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
case UnaryOperand.Not:
return(Expression.Not(expressionInterpreterHandler.
GetExpression(
unaryStatement.Operand)));
case UnaryOperand.OnesComplement:
return(Expression.OnesComplement(expressionInterpreterHandler
.GetExpression(
unaryStatement.Operand)));
default:
throw new NotSupportedException(unaryStatement.Operand + " is not suppoted unary statement");
}
}
public Expression GetExpression()
{
var suppliedArgs = invocationStatement.Arguments;
var arguments = invocationStatement.Arguments
.Select(x => expressionInterpreterHandler.GetExpression(x)).ToArray();
var parameterTypes = invocationStatement.ParametersSignature.Select(x => (Type)x).ToArray();
var methodKey = GetMethodKey();
var lamdaExpression = RuntimeMemory.GetMethod(invocationStatement.Method.ParentType, methodKey);
var instanceMember = invocationStatement.Method as InstanceMethodMemberStatement;
if (lamdaExpression != null)
{
var expression = lamdaExpression.GetExpression();
var arguments1 = new List <Expression>();
if (instanceMember != null)
{
arguments1.Add(expressionInterpreterHandler.GetExpression(instanceMember.Parent));
}
arguments1.AddRange(arguments);
return(Expression.Invoke(expression, arguments1));
}
BindingFlags bindingFlags = instanceMember == null ? BindingFlags.Static : BindingFlags.Instance;
bindingFlags |= invocationStatement.Method.AccessModifier == HotReloading.Core.AccessModifier.Public ?
BindingFlags.Public : BindingFlags.NonPublic;
Type declareType = (Type)invocationStatement.Method.ParentType;
var methodInfo =
declareType.GetMethod(invocationStatement.Method.Name,
bindingFlags, Type.DefaultBinder, parameterTypes, null);
Expression[] convertedArguments = new Expression[arguments.Length];
for (int i = 0; i < convertedArguments.Length; i++)
{
var argument = arguments[i];
var parameter = methodInfo.GetParameters()[i];
if (parameter.ParameterType != argument.Type)
{
convertedArguments[i] = Expression.Convert(argument, parameter.ParameterType);
}
else
{
convertedArguments[i] = argument;
}
}
if (instanceMember != null)
{
var caller = expressionInterpreterHandler.GetExpression(instanceMember.Parent);
return(Expression.Call(
caller,
methodInfo, convertedArguments));
}
return(Expression.Call(methodInfo, convertedArguments));
}
public Expression GetExpression()
{
var instanceType = (Type)creationStatement.Type;
var arguments = new List <Expression>();
foreach (var argument in creationStatement.ArgumentList)
{
arguments.Add(expressionInterpreterHandler.GetExpression(argument));
}
var argumentTypes = arguments.Select(x => x.Type).ToArray();
var ctorInfo = instanceType.GetConstructor(argumentTypes);
Expression[] convertedArguments = new Expression[arguments.Count];
for (int i = 0; i < convertedArguments.Length; i++)
{
var argument = arguments[i];
var parameter = ctorInfo.GetParameters()[i];
if (parameter.ParameterType != argument.Type)
{
convertedArguments[i] = Expression.Convert(argument, parameter.ParameterType);
}
else
{
convertedArguments[i] = argument;
}
}
var ctorExpression = Expression.New(ctorInfo, convertedArguments);
if (creationStatement.Initializer.Any())
{
if (instanceType.IsGenericType)
{
var list = typeof(List <>);
if (instanceType.GenericTypeArguments.Length == 1)
{
var genericList = list.MakeGenericType(instanceType.GenericTypeArguments);
if (genericList == instanceType)
{
var addMethod = genericList.GetMethod("Add");
List <ElementInit> initializers = new List <ElementInit>();
foreach (var element in creationStatement.Initializer)
{
var elementInit = Expression.ElementInit(addMethod, expressionInterpreterHandler.GetExpression(element)
);
initializers.Add(elementInit);
}
return(Expression.ListInit(ctorExpression, initializers));
}
}
var dic = typeof(Dictionary <,>);
if (instanceType.GenericTypeArguments.Length == 2)
{
var genericDic = dic.MakeGenericType(instanceType.GenericTypeArguments);
if (genericDic == instanceType)
{
var addMethod = genericDic.GetMethod("Add");
List <ElementInit> initializers = new List <ElementInit>();
foreach (var element in creationStatement.Initializer)
{
if (element is InitializerStatement initializerStatement)
{
var initExpression = initializerStatement.Statements.Select(x =>
expressionInterpreterHandler.GetExpression(x));
var elementInit = Expression.ElementInit(addMethod, initExpression);
initializers.Add(elementInit);
}
else
{
throw new NotSupportedException("This dictionary initialization is not supported");
}
}
return(Expression.ListInit(ctorExpression, initializers));
}
}
}
var membersInitalizer = new List <MemberBinding>();
foreach (var statement in creationStatement.Initializer.Cast <BinaryStatement>())
{
if (statement.Operand != BinaryOperand.Assign)
{
throw new NotSupportedException("This operation is not supported");
}
string memberName = "";
if (statement.Left is InstanceFieldMemberStatement field)
{
memberName = field.Name;
}
else if (statement.Left is InstancePropertyMemberStatement property)
{
memberName = property.Name;
}
else
{
throw new NotSupportedException("This operation is not supported yet");
}
var member = instanceType.GetMostSuitableMember(memberName);
var rightExpression = expressionInterpreterHandler.GetExpression(statement.Right);
if (member is FieldInfo fi && fi.FieldType != rightExpression.Type)
{
rightExpression = Expression.Convert(rightExpression, fi.FieldType);
}
else if (member is PropertyInfo pi && pi.PropertyType != rightExpression.Type)
{
rightExpression = Expression.Convert(rightExpression, pi.PropertyType);
}
membersInitalizer.Add(Expression.Bind(member, rightExpression));
}
public Expression GetExpression()
{
var expression = expressionInterpreterHandler.GetExpression(asTypeStatement.Statement);
return(Expression.TypeAs(expression, asTypeStatement.Type));
}
public Expression GetExpression()
{
return(Expression.Condition(expressionInterpreterHandler.GetExpression(conditionalStatement.Condition),
expressionInterpreterHandler.GetExpression(conditionalStatement.IfTrue),
expressionInterpreterHandler.GetExpression(conditionalStatement.IfFalse)));
}
public Expression GetExpression()
{
var expression = expressionInterpreterHandler.GetExpression(awaitStatement.Statement);
return(CSharpExpression.Await(expression));
}