internal static NegateChecked NegateChecked(UnaryExpression expression)
{
return(new NegateChecked()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
public static ElementInit Serialize(E.ElementInit elementInit)
{
return(new ElementInit()
{
AddMethod = MethodRef.Serialize(elementInit.AddMethod),
Arguments = elementInit.Arguments.Select(Node.Serialize).ToArray(),
});
}
internal static Increment Increment(UnaryExpression expression)
{
return(new Increment()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static Subtract Subtract(BinaryExpression expression)
{
return(new Subtract()
{
Left = Serialize(expression.Left),
Right = Serialize(expression.Right),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static Convert Convert(UnaryExpression expression)
{
return(new Convert()
{
Operand = Serialize(expression.Operand),
Type = TypeRef.Serialize(expression.Type),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
});
}
internal static MultiplyChecked MultiplyChecked(BinaryExpression expression)
{
return(new MultiplyChecked()
{
Left = Serialize(expression.Left),
Right = Serialize(expression.Right),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static Rethrow Rethrow(UnaryExpression expression)
{
return(new Rethrow()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
Type = expression.Type.Null(t => TypeRef.Serialize(t)),
}.If(n => n.Type == null, n => n.TypeHint = TypeRef.Serialize(expression.Type)));
}
internal static Call Call(MethodCallExpression expression)
{
return(new Call()
{
Method = MethodRef.Serialize(expression.Method),
Object = expression.Object.Null(e => Serialize(e)),
Arguments = expression.Arguments.Select(Serialize).ToArray(),
IsExtension = expression.Method.IsExtensionMethod(),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static OrAssign OrAssign(BinaryExpression expression)
{
return(new OrAssign()
{
Left = Serialize(expression.Left),
Right = Serialize(expression.Right),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
Conversion = expression.Conversion.Null(e => Lambda(e)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static LessThanOrEqual LessThanOrEqual(BinaryExpression expression)
{
return(new LessThanOrEqual()
{
Left = Serialize(expression.Left),
Right = Serialize(expression.Right),
LiftToNull = expression.IsLiftedToNull,
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
internal static Switch Switch(SwitchExpression expression)
{
return(new Switch()
{
Type = expression.Type != expression.Cases[0].Body.Type
? TypeRef.Serialize(expression.Type)
: null,
SwitchValue = Serialize(expression.SwitchValue),
Cases = expression.Cases.Select(SwitchCase.Serialize).ToArray(),
DefaultBody = expression.DefaultBody.Null(e => Serialize(e)),
Comparison = expression.Comparison.Null(m => MethodRef.Serialize(m)),
}.If(n => n.Type == null, n => n.TypeHint = TypeRef.Serialize(expression.Type)));
}
internal static New New(NewExpression expression)
{
return(new New()
{
Constructor = MethodRef.Serialize(expression.Constructor),
Arguments = expression.Arguments.Select(Serialize).ToArray(),
Members = expression.Members.If(
ms => ms != null && ms.Any(),
ms => ms.Select(MemberRef.Serialize).ToArray(),
_ => null
),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type)));
}
/// <summary>
/// Returns the member reference which refers specified member.
/// </summary>
/// <param name="member">The member to refer.</param>
/// <returns>The member reference which refers specified member.</returns>
public static MemberRef Serialize(MemberInfo member)
{
switch (member.MemberType)
{
case MemberTypes.Constructor:
case MemberTypes.Method:
return(MethodRef.Serialize((MethodBase)member));
case MemberTypes.Event:
return(EventRef.Serialize((EventInfo)member));
case MemberTypes.Field:
return(FieldRef.Serialize((FieldInfo)member));
case MemberTypes.Property:
return(PropertyRef.Serialize((PropertyInfo)member));
default:
throw new ArgumentOutOfRangeException("member.MemberType");
}
}