public override StringBuilder VisitInvocationExpression(InvocationExpression invocationExpression, int data)
{
var result = new StringBuilder();
var mref = invocationExpression.Annotation <MethodReference>();
var m = mref != null?mref.Resolve() : invocationExpression.Annotation <MethodDefinition>();
if (m.DeclaringType.MetadataToken.ToInt32() == typeof(ASLShader).MetadataToken)
{
if (m.Name == "__output")
{
return(result.Append(ArgsToString(invocationExpression.Arguments)));
}
else
{
return(result.Append(m.Name).Append("(").Append(ArgsToString(invocationExpression.Arguments)).Append(")"));
}
}
RegisterMethod(m);
result.Append(m.Name);
result.Append("(").Append(ArgsToString(invocationExpression.Arguments)).Append(")");
return(result);
}
/// <summary>
/// Translates an invocation expression, e.g. "Math.Max(10, 5)".
/// </summary>
public override StringBuilder VisitInvocationExpression(InvocationExpression invocationExpr)
{
var result = new StringBuilder();
var methodDef = invocationExpr.Annotation <MethodDefinition>() ??
invocationExpr.Annotation <MethodReference>().Resolve();
var methodName = methodDef.Name;
var declType = methodDef.DeclaringType.ToType();
var args = JoinArgs(invocationExpr.Arguments).ToString();
// map method if it's a mathematical method or
// map method if it's a xSLShader class' method
if (ShaderMapping.Types.ContainsKey(declType))
{
if (ShaderMapping.Methods.ContainsKey(methodName))
{
var mappedName = ShaderMapping.Methods[methodName];
return(result.Method(mappedName, args));
}
}
// otherwise just call the method
if (declType != typeof(xSLShader))
{
RefMethods.Add(methodDef);
}
return(result.Method(methodDef.Name, args));
}
public override AstNode VisitInvocationExpression(InvocationExpression invocationExpression, ICecilArgumentsResolver argumentsResolver)
{
MethodReference reference = null;
invocationExpression.Arguments.ForEach(a => a.AcceptVisitor(this, argumentsResolver));
invocationExpression.Target.AcceptVisitor(this, argumentsResolver);
var specification = invocationExpression.Annotation <MethodSpecification>();
if (specification != null && specification.IsGenericInstance)
{
var genericMethod = specification as GenericInstanceMethod;
var genericArguments = genericMethod.GenericArguments.ToArray();
var parameters = genericMethod.Parameters.Select(p => p.ParameterType);
reference = specification.GetElementMethod();
reference = ResolveGenericMethod(parameters, reference, genericArguments, argumentsResolver);
invocationExpression.RemoveAnnotations <MethodSpecification>();
invocationExpression.AddAnnotation(reference);
}
else
{
reference = invocationExpression.Annotation <MethodReference>();
if (reference != null)
{
TypeReference returnType = reference.ReturnType;
TypeReference declaringType = reference.DeclaringType;
if (declaringType.IsGenericInstance || returnType.IsGenericParameter)
{
if (declaringType.IsGenericInstance)
{
var genericMethod = declaringType as GenericInstanceType;
var parameters = reference.Parameters.Select(p => p.ParameterType);
reference = ResolveGenericMethod(parameters, reference, genericMethod.GenericArguments, argumentsResolver);
genericMethod.GenericArguments.Clear();
reference.GenericParameters.ForEach(p => genericMethod.GenericArguments.Add(p));
}
if (reference.ReturnType.IsGenericParameter)
{
var genericInstanceType = declaringType as GenericInstanceType;
var genericParameter = reference.ReturnType as GenericParameter;
var genericReturnType = genericParameter.GetGenericActualType(genericInstanceType.GenericArguments.ToArray());
reference = reference.MakeGenericMethod(new TypeReference[] { }, genericReturnType);
}
invocationExpression.RemoveAnnotations <MethodReference>();
invocationExpression.AddAnnotation(reference);
}
}
}
return(invocationExpression);
}
public static bool CouldBeExpressionTree(InvocationExpression expr)
{
if (expr != null && expr.Arguments.Count == 2) {
IMethod mr = expr.Annotation<IMethod>();
return mr != null && mr.Name == "Lambda" && mr.DeclaringType.FullName == "System.Linq.Expressions.Expression";
}
return false;
}
public static bool CouldBeExpressionTree(InvocationExpression expr)
{
if (expr != null && expr.Arguments.Count == 2)
{
IMethod mr = expr.Annotation <IMethod>();
return(mr != null && mr.Name == "Lambda" && mr.DeclaringType != null && mr.DeclaringType.FullName == "System.Linq.Expressions.Expression");
}
return(false);
}
public override StringBuilder VisitInvocationExpression(InvocationExpression invocationExpression, int data)
{
var result = new StringBuilder();
var mref = invocationExpression.Annotation <MethodReference>();
var m = mref != null?mref.Resolve() : invocationExpression.Annotation <MethodDefinition>();
if (m.DeclaringType.MetadataToken.ToInt32() == typeof(ShaderDefinition).MetadataToken)
{
return(VisitShaderDefCall(m, invocationExpression));
}
RegisterMethod(m);
result.Append(Shader.GetMethodName(m));
result.Append("(").Append(ArgsToString(invocationExpression.Arguments)).Append(")");
return(result);
}
public override bool DoMatch(INode other, Match match)
{
InvocationExpression ie = other as InvocationExpression;
if (ie != null && ie.Annotation <LdTokenAnnotation>() != null && ie.Arguments.Count == 1)
{
return(childNode.DoMatch(ie.Arguments.Single(), match));
}
return(false);
}
private bool IsLambdaInvocation(InvocationExpression invocation)
{
if (invocation != null)
{
var methodReference = invocation.Annotation <MethodReference>();
if (methodReference.Name.Equals("Lambda") && methodReference.DeclaringType.FullName.Equals("System.Linq.Expressions.Expression"))
{
return(true);
}
}
return(false);
}
public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
ExpressionStatement stmt = constructorDeclaration.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (stmt == null)
{
return(null);
}
InvocationExpression invocation = stmt.Expression as InvocationExpression;
if (invocation == null)
{
return(null);
}
MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression;
if (mre != null && mre.MemberName == ".ctor")
{
ConstructorInitializer ci = new ConstructorInitializer();
if (mre.Target is ThisReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
else if (mre.Target is BaseReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
return(null);
}
// Move arguments from invocation to initializer:
invocation.Arguments.MoveTo(ci.Arguments);
var ilRanges = stmt.GetAllRecursiveILRanges();
// Add the initializer: (unless it is the default 'base()')
if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
{
constructorDeclaration.Initializer = ci.WithAnnotation(invocation.Annotation <IMethod>());
ci.AddAnnotation(ilRanges);
}
else
{
constructorDeclaration.Body.HiddenStart = NRefactoryExtensions.CreateHidden(ilRanges, constructorDeclaration.Body.HiddenStart);
}
// Remove the statement:
stmt.Remove();
}
return(null);
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (context.Settings.ExpressionTrees && ExpressionTreeConverter.CouldBeExpressionTree(invocationExpression))
{
Expression converted = ExpressionTreeConverter.TryConvert(context, invocationExpression);
if (converted != null)
{
invocationExpression.ReplaceWith(converted);
return(converted.AcceptVisitor(this, data));
}
}
var definition = invocationExpression.Annotation <MethodDefinition>();
if (definition != null)
{
//Handle hoisted base calls from yield return compiler generated class (can be generated by both Mono and Roslyn)
if (definition.DeclaringType == context.CurrentType && definition.IsCompilerGenerated())
{
DecompilerContext subContext = context.Clone();
subContext.CurrentMethod = definition;
subContext.CurrentMethodIsAsync = false;
subContext.ReservedVariableNames.AddRange(currentlyUsedVariableNames);
var parameters = AstBuilder.MakeParameters(definition, isLambda: true);
BlockStatement body = AstMethodBodyBuilder.CreateMethodBody(definition, subContext, parameters);
TransformationPipeline.RunTransformationsUntil(body, v => v is DelegateConstruction, subContext);
if (body.Statements.Count == 1)
{
var statement = body.Statements.Single();
Expression expr = null;
if (statement is ReturnStatement)
{
expr = ((ReturnStatement)statement).Expression;
}
else if (statement is ExpressionStatement)
{
expr = ((ExpressionStatement)statement).Expression;
}
if (expr != null)
{
expr.Remove();
invocationExpression.ReplaceWith(expr);
return(expr.AcceptVisitor(this, data));
}
}
}
}
return(base.VisitInvocationExpression(invocationExpression, data));
}
public override StringBuilder VisitInvocationExpression(InvocationExpression invocationExpression, int data)
{
var result = new StringBuilder();
var mref = invocationExpression.Annotation<MethodReference>();
var m = mref != null ? mref.Resolve() : invocationExpression.Annotation<MethodDefinition>();
if (m.DeclaringType.MetadataToken.ToInt32() == typeof(ShaderDefinition).MetadataToken)
return VisitShaderDefCall(m, invocationExpression);
RegisterMethod(m);
result.Append(Shader.GetMethodName(m));
result.Append("(").Append(ArgsToString(invocationExpression.Arguments)).Append(")");
return result;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
base.VisitInvocationExpression(invocationExpression, data);
MethodReference methodRef = invocationExpression.Annotation <MethodReference>();
if (methodRef == null)
{
return(null);
}
var arguments = invocationExpression.Arguments.ToArray();
// Reduce "String.Concat(a, b)" to "a + b"
if (methodRef.Name == "Concat" && methodRef.DeclaringType.FullName == "System.String" && arguments.Length >= 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
Expression expr = arguments[0];
for (int i = 1; i < arguments.Length; i++)
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.Add, arguments[i]);
}
invocationExpression.ReplaceWith(expr);
return(null);
}
switch (methodRef.FullName)
{
case "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)":
if (arguments.Length == 1)
{
if (typeHandleOnTypeOfPattern.IsMatch(arguments[0]))
{
invocationExpression.ReplaceWith(((MemberReferenceExpression)arguments[0]).Target);
return(null);
}
}
break;
}
BinaryOperatorType?bop = GetBinaryOperatorTypeFromMetadataName(methodRef.Name);
if (bop != null && arguments.Length == 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
invocationExpression.ReplaceWith(
new BinaryOperatorExpression(arguments[0], bop.Value, arguments[1]).WithAnnotation(methodRef)
);
return(null);
}
UnaryOperatorType?uop = GetUnaryOperatorTypeFromMetadataName(methodRef.Name);
if (uop != null && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
new UnaryOperatorExpression(uop.Value, arguments[0]).WithAnnotation(methodRef)
);
return(null);
}
if (methodRef.Name == "op_Explicit" && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
arguments[0].CastTo(AstBuilder.ConvertType(methodRef.ReturnType, methodRef.MethodReturnType))
.WithAnnotation(methodRef)
);
return(null);
}
if (methodRef.Name == "op_Implicit" && arguments.Length == 1)
{
invocationExpression.ReplaceWith(arguments[0]);
return(null);
}
if (methodRef.Name == "op_True" && arguments.Length == 1 && invocationExpression.Role == AstNode.Roles.Condition)
{
invocationExpression.ReplaceWith(arguments[0]);
return(null);
}
return(null);
}
Expression Convert(Expression expr)
{
InvocationExpression invocation = expr as InvocationExpression;
if (invocation != null)
{
IMethod mr = invocation.Annotation <IMethod>();
if (mr != null && mr.DeclaringType != null && mr.DeclaringType.FullName == "System.Linq.Expressions.Expression")
{
switch (mr.Name)
{
case "Add":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Add, false));
case "AddChecked":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Add, true));
case "AddAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Add, false));
case "AddAssignChecked":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Add, true));
case "And":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.BitwiseAnd));
case "AndAlso":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.ConditionalAnd));
case "AndAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.BitwiseAnd));
case "ArrayAccess":
case "ArrayIndex":
return(ConvertArrayIndex(invocation));
case "ArrayLength":
return(ConvertArrayLength(invocation));
case "Assign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Assign));
case "Call":
return(ConvertCall(invocation));
case "Coalesce":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.NullCoalescing));
case "Condition":
return(ConvertCondition(invocation));
case "Constant":
if (invocation.Arguments.Count >= 1)
{
return(invocation.Arguments.First().Clone());
}
else
{
return(NotSupported(expr));
}
case "Convert":
return(ConvertCast(invocation, false));
case "ConvertChecked":
return(ConvertCast(invocation, true));
case "Divide":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Divide));
case "DivideAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Divide));
case "Equal":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Equality));
case "ExclusiveOr":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.ExclusiveOr));
case "ExclusiveOrAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.ExclusiveOr));
case "Field":
return(ConvertField(invocation));
case "GreaterThan":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.GreaterThan));
case "GreaterThanOrEqual":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.GreaterThanOrEqual));
case "Invoke":
return(ConvertInvoke(invocation));
case "Lambda":
return(ConvertLambda(invocation));
case "LeftShift":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.ShiftLeft));
case "LeftShiftAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.ShiftLeft));
case "LessThan":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.LessThan));
case "LessThanOrEqual":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.LessThanOrEqual));
case "ListInit":
return(ConvertListInit(invocation));
case "MemberInit":
return(ConvertMemberInit(invocation));
case "Modulo":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Modulus));
case "ModuloAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Modulus));
case "Multiply":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Multiply, false));
case "MultiplyChecked":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Multiply, true));
case "MultiplyAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Multiply, false));
case "MultiplyAssignChecked":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Multiply, true));
case "Negate":
return(ConvertUnaryOperator(invocation, UnaryOperatorType.Minus, false));
case "NegateChecked":
return(ConvertUnaryOperator(invocation, UnaryOperatorType.Minus, true));
case "New":
return(ConvertNewObject(invocation));
case "NewArrayBounds":
return(ConvertNewArrayBounds(invocation));
case "NewArrayInit":
return(ConvertNewArrayInit(invocation));
case "Not":
return(ConvertUnaryOperator(invocation, UnaryOperatorType.Not));
case "NotEqual":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.InEquality));
case "OnesComplement":
return(ConvertUnaryOperator(invocation, UnaryOperatorType.BitNot));
case "Or":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.BitwiseOr));
case "OrAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.BitwiseOr));
case "OrElse":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.ConditionalOr));
case "Property":
return(ConvertProperty(invocation));
case "Quote":
if (invocation.Arguments.Count == 1)
{
return(Convert(invocation.Arguments.Single()));
}
else
{
return(NotSupported(invocation));
}
case "RightShift":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.ShiftRight));
case "RightShiftAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.ShiftRight));
case "Subtract":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Subtract, false));
case "SubtractChecked":
return(ConvertBinaryOperator(invocation, BinaryOperatorType.Subtract, true));
case "SubtractAssign":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Subtract, false));
case "SubtractAssignChecked":
return(ConvertAssignmentOperator(invocation, AssignmentOperatorType.Subtract, true));
case "TypeAs":
return(ConvertTypeAs(invocation));
case "TypeIs":
return(ConvertTypeIs(invocation));
}
}
}
IdentifierExpression ident = expr as IdentifierExpression;
if (ident != null)
{
ILVariable v = ident.Annotation <ILVariable>();
if (v != null)
{
foreach (LambdaExpression lambda in activeLambdas)
{
foreach (ParameterDeclaration p in lambda.Parameters)
{
if (p.Annotation <ILVariable>() == v)
{
return(IdentifierExpression.Create(p.Name, v.IsParameter ? TextTokenKind.Parameter : TextTokenKind.Local).WithAnnotation(v));
}
}
}
}
}
return(NotSupported(expr));
}
public override void VisitInvocationExpression (InvocationExpression invocationExpression)
{
base.VisitInvocationExpression (invocationExpression);
var mr = invocationExpression.Target as MemberReferenceExpression;
if (mr == null)
return;
if (mr.MemberName != "Equals")
return;
var m = invocationExpression.Annotation<MemberReference> ();
if (m.DeclaringType.FullName != "System.Object")
return;
var i = new InvocationExpression (
new MemberReferenceExpression (new TypeReferenceExpression (new SimpleType ("NObject")), "GenericEquals"),
mr.Target.Clone (), invocationExpression.Arguments.First ().Clone ());
invocationExpression.ReplaceWith (i);
}
internal static void ProcessInvocationExpression(InvocationExpression invocationExpression)
{
MethodReference methodRef = invocationExpression.Annotation <MethodReference>();
if (methodRef == null)
{
return;
}
var arguments = invocationExpression.Arguments.ToArray();
// Reduce "String.Concat(a, b)" to "a + b"
if (methodRef.Name == "Concat" && methodRef.DeclaringType.FullName == "System.String" && arguments.Length >= 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
Expression expr = arguments[0];
for (int i = 1; i < arguments.Length; i++)
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.Add, arguments[i]);
}
invocationExpression.ReplaceWith(expr);
return;
}
switch (methodRef.FullName)
{
case "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)":
if (arguments.Length == 1)
{
if (typeHandleOnTypeOfPattern.IsMatch(arguments[0]))
{
invocationExpression.ReplaceWith(((MemberReferenceExpression)arguments[0]).Target);
return;
}
}
break;
case "System.Reflection.FieldInfo System.Reflection.FieldInfo::GetFieldFromHandle(System.RuntimeFieldHandle)":
if (arguments.Length == 1)
{
MemberReferenceExpression mre = arguments[0] as MemberReferenceExpression;
if (mre != null && mre.MemberName == "FieldHandle" && mre.Target.Annotation <LdTokenAnnotation>() != null)
{
invocationExpression.ReplaceWith(mre.Target);
return;
}
}
break;
case "System.Reflection.FieldInfo System.Reflection.FieldInfo::GetFieldFromHandle(System.RuntimeFieldHandle,System.RuntimeTypeHandle)":
if (arguments.Length == 2)
{
MemberReferenceExpression mre1 = arguments[0] as MemberReferenceExpression;
MemberReferenceExpression mre2 = arguments[1] as MemberReferenceExpression;
if (mre1 != null && mre1.MemberName == "FieldHandle" && mre1.Target.Annotation <LdTokenAnnotation>() != null)
{
if (mre2 != null && mre2.MemberName == "TypeHandle" && mre2.Target is TypeOfExpression)
{
Expression oldArg = ((InvocationExpression)mre1.Target).Arguments.Single();
FieldReference field = oldArg.Annotation <FieldReference>();
if (field != null)
{
AstType declaringType = ((TypeOfExpression)mre2.Target).Type.Detach();
oldArg.ReplaceWith(declaringType.Member(field.Name).WithAnnotation(field));
invocationExpression.ReplaceWith(mre1.Target);
return;
}
}
}
}
break;
}
BinaryOperatorType?bop = GetBinaryOperatorTypeFromMetadataName(methodRef.Name);
if (bop != null && arguments.Length == 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
invocationExpression.ReplaceWith(
new BinaryOperatorExpression(arguments[0], bop.Value, arguments[1]).WithAnnotation(methodRef)
);
return;
}
UnaryOperatorType?uop = GetUnaryOperatorTypeFromMetadataName(methodRef.Name);
if (uop != null && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
new UnaryOperatorExpression(uop.Value, arguments[0]).WithAnnotation(methodRef)
);
return;
}
if (methodRef.Name == "op_Explicit" && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
arguments[0].CastTo(AstBuilder.ConvertType(methodRef.ReturnType, methodRef.MethodReturnType))
.WithAnnotation(methodRef)
);
return;
}
if (methodRef.Name == "op_Implicit" && arguments.Length == 1)
{
invocationExpression.ReplaceWith(arguments[0]);
return;
}
if (methodRef.Name == "op_True" && arguments.Length == 1 && invocationExpression.Role == Roles.Condition)
{
invocationExpression.ReplaceWith(arguments[0]);
return;
}
return;
}
internal static void ProcessInvocationExpression(InvocationExpression invocationExpression, StringBuilder sb)
{
IMethod methodRef = invocationExpression.Annotation <IMethod>();
if (methodRef == null)
{
return;
}
var arguments = invocationExpression.Arguments.ToArray();
// Reduce "String.Concat(a, b)" to "a + b"
if (methodRef.Name == "Concat" && methodRef.DeclaringType != null && arguments.Length >= 2 && methodRef.DeclaringType.FullName == "System.String")
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
Expression expr = arguments[0];
for (int i = 1; i < arguments.Length; i++)
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.Add, arguments[i]);
}
invocationExpression.ReplaceWith(expr);
expr.AddAnnotation(invocationExpression.GetAllRecursiveILRanges());
return;
}
bool isSupportedType = CheckType(methodRef.DeclaringType, systemString, typeString) ||
CheckType(methodRef.DeclaringType, systemReflectionString, fieldInfoString);
switch (isSupportedType ? methodRef.Name.String : string.Empty)
{
case "GetTypeFromHandle":
if (arguments.Length == 1 && methodRef.FullName == "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)")
{
if (typeHandleOnTypeOfPattern.IsMatch(arguments[0]))
{
invocationExpression.ReplaceWith(((MemberReferenceExpression)arguments[0]).Target
.WithAnnotation(invocationExpression.GetAllRecursiveILRanges()));
return;
}
}
break;
case "GetFieldFromHandle":
if (arguments.Length == 1 && methodRef.FullName == "System.Reflection.FieldInfo System.Reflection.FieldInfo::GetFieldFromHandle(System.RuntimeFieldHandle)")
{
MemberReferenceExpression mre = arguments[0] as MemberReferenceExpression;
if (mre != null && mre.MemberName == "FieldHandle" && mre.Target.Annotation <LdTokenAnnotation>() != null)
{
invocationExpression.ReplaceWith(mre.Target
.WithAnnotation(invocationExpression.GetAllRecursiveILRanges()));
return;
}
}
else if (arguments.Length == 2 && methodRef.FullName == "System.Reflection.FieldInfo System.Reflection.FieldInfo::GetFieldFromHandle(System.RuntimeFieldHandle,System.RuntimeTypeHandle)")
{
MemberReferenceExpression mre1 = arguments[0] as MemberReferenceExpression;
MemberReferenceExpression mre2 = arguments[1] as MemberReferenceExpression;
if (mre1 != null && mre1.MemberName == "FieldHandle" && mre1.Target.Annotation <LdTokenAnnotation>() != null)
{
if (mre2 != null && mre2.MemberName == "TypeHandle" && mre2.Target is TypeOfExpression)
{
Expression oldArg = ((InvocationExpression)mre1.Target).Arguments.Single();
IField field = oldArg.Annotation <IField>();
if (field != null)
{
var ilRanges = invocationExpression.GetAllRecursiveILRanges();
AstType declaringType = ((TypeOfExpression)mre2.Target).Type.Detach();
oldArg.ReplaceWith(declaringType.Member(field.Name, field).WithAnnotation(field));
invocationExpression.ReplaceWith(mre1.Target.WithAnnotation(ilRanges));
return;
}
}
}
}
break;
}
BinaryOperatorType?bop = GetBinaryOperatorTypeFromMetadataName(methodRef.Name);
if (bop != null && arguments.Length == 2)
{
invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression
invocationExpression.ReplaceWith(
new BinaryOperatorExpression(arguments[0], bop.Value, arguments[1]).WithAnnotation(methodRef)
.WithAnnotation(invocationExpression.GetAllRecursiveILRanges())
);
return;
}
UnaryOperatorType?uop = GetUnaryOperatorTypeFromMetadataName(methodRef.Name);
if (uop != null && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
new UnaryOperatorExpression(uop.Value, arguments[0]).WithAnnotation(methodRef)
.WithAnnotation(invocationExpression.GetAllRecursiveILRanges())
);
return;
}
if (methodRef.Name == "op_Explicit" && arguments.Length == 1)
{
arguments[0].Remove(); // detach argument
invocationExpression.ReplaceWith(
arguments[0].CastTo(AstBuilder.ConvertType(methodRef.MethodSig.GetRetType(), sb))
.WithAnnotation(methodRef)
.WithAnnotation(invocationExpression.GetAllRecursiveILRanges())
);
return;
}
if (methodRef.Name == "op_Implicit" && arguments.Length == 1)
{
invocationExpression.ReplaceWith(arguments[0].WithAnnotation(invocationExpression.GetAllRecursiveILRanges()));
return;
}
if (methodRef.Name == "op_True" && arguments.Length == 1 && invocationExpression.Role == Roles.Condition)
{
invocationExpression.ReplaceWith(arguments[0].WithAnnotation(invocationExpression.GetAllRecursiveILRanges()));
return;
}
return;
}
public override void VisitInvocationExpression(InvocationExpression e)
{
var md = e.Annotation<MethodDefinition>();
if (md != null && (md.IsGetter || md.IsSetter))
{
var p = md.DeclaringType.Properties.FirstOrDefault(x => x.GetMethod == md || x.SetMethod == md);
if (p != null)
{
// 转换为属性访问
var target = (e.Target as MemberReferenceExpression).Target;
if (p.IsIndexer())
{
IndexerExpression ie = new IndexerExpression(target.Detach()).WithAnnotation(p);
e.Arguments.MoveTo(ie.Arguments);
e.ReplaceWith(ie);
}
else
{
//MemberReferenceExpression mre = new MemberReferenceExpression(target.Detach(), p.Name).WithAnnotation(p);
}
}
}
//[CompilerGenerated]
//private sealed class C_e_5
//{
// public Action f_1_E2DC5B04;
// public void M_1_void(object x)
// {
// this.f_1_E2DC5B04();
// }
//}
//
//public ActionCommand(Action execute)
//{
// Action<object> action = null;
// ActionCommand.C_e_5 c_e_ = new ActionCommand.C_e_5();
// c_e_.f_1_E2DC5B04 = execute;
// if (action == null)
// {
// action = new Action<object>(c_e_.M_1_void);
// }
// base..ctor(action);
//}
//
//====>
//public ActionCommand(Action execute) : base(x=>execute())
//{
//}
base.VisitInvocationExpression(e);
}
