private PropertyReferenceExpression(MethodReferenceExpression methodExpression, PropertyDefinition property, bool virtualCall, IEnumerable <Instruction> instructions)
: base(methodExpression, instructions)
{
this.MethodExpression = methodExpression;
this.Property = property;
this.VirtualCall = virtualCall;
}
public MethodInvocationExpression(MethodReferenceExpression method, IEnumerable <Instruction> instructions)
{
base(instructions);
this.set_MethodExpression(method);
this.set_Arguments(new ExpressionCollection());
return;
}
private void CopyFields(MethodReferenceExpression clone)
{
clone.resolved = this.resolved;
clone.methodDefinition = this.methodDefinition;
clone.expressionType = this.expressionType;
return;
}
public override bool Equals(Expression other)
{
if (other == null)
{
return(false);
}
if (other is MethodReferenceExpression == false)
{
return(false);
}
MethodReferenceExpression otherRef = other as MethodReferenceExpression;
#region CompareTargets
if (this.Target == null)
{
if (otherRef.Target != null)
{
return(false);
}
}
else if (!this.Target.Equals(otherRef.Target))
{
return(false);
}
#endregion
/// At this point we know that either both targets are null, or both targets are equal expressions
#region MethodSignature
if (this.Method.FullName != otherRef.Method.FullName)
{
return(false);
}
#endregion
return(true);
}
private PropertyReferenceExpression(MethodReferenceExpression methodExpression, PropertyDefinition property, bool virtualCall, IEnumerable <Instruction> instructions)
{
base(methodExpression, instructions);
this.set_MethodExpression(methodExpression);
this.set_Property(property);
this.set_VirtualCall(virtualCall);
return;
}
public override Expression Clone()
{
Expression targetClone = Target != null?Target.Clone() : null;
MethodReferenceExpression result = new MethodReferenceExpression(targetClone, this.Method, this.instructions);
CopyFields(result);
return(result);
}
public override Expression CloneExpressionOnly()
{
MethodReferenceExpression methodExpressionClone = (MethodReferenceExpression)this.MethodExpression.CloneExpressionOnly();
PropertyReferenceExpression result = new PropertyReferenceExpression(methodExpressionClone, this.Property, this.VirtualCall, null)
{
Arguments = this.Arguments.CloneExpressionsOnly()
};
return(result);
}
public override Expression CloneExpressionOnly()
{
if (this.get_Target() != null)
{
stackVariable4 = this.get_Target().CloneExpressionOnly();
}
else
{
stackVariable4 = null;
}
V_0 = new MethodReferenceExpression(stackVariable4, this.get_Method(), null);
this.CopyFields(V_0);
return(V_0);
}
public override ICodeNode VisitMethodReferenceExpression(MethodReferenceExpression node)
{
MethodDefinition methodDefinition = node.Method.Resolve();
TypeDefinition currentType = context.TypeContext.CurrentType;
if (methodDefinition == null ||
methodDefinition.DeclaringType != currentType && !methodDefinition.DeclaringType.IsNestedIn(currentType))
{
return base.VisitMethodReferenceExpression(node);
}
if ((!methodDefinition.IsGetter) && (!methodDefinition.IsSetter) &&
(methodDefinition.IsCompilerGenerated() || CheckTypeForCompilerGeneratedAttribute(methodDefinition.DeclaringType)))
{
BlockStatement statement = null;
if (methodDefinition.Body != null)
{
DecompilationContext innerContext = CreateDecompilationContext(methodDefinition);
statement = methodDefinition.Body.DecompileLambda(this.context.Language, innerContext);
if ((statement.Statements.Count == 1) && (statement.Statements[0].CodeNodeType == CodeNodeType.ExpressionStatement) &&
((statement.Statements[0] as ExpressionStatement).Expression.CodeNodeType == CodeNodeType.ReturnExpression))
{
ReturnExpression returnExpression = (statement.Statements[0] as ExpressionStatement).Expression as ReturnExpression;
ShortFormReturnExpression shortFormReturnExpression = new ShortFormReturnExpression(returnExpression.Value, returnExpression.MappedInstructions);
statement = new BlockStatement();
statement.Statements.Add(new ExpressionStatement(shortFormReturnExpression));
}
this.context.MethodContext.VariableDefinitionToNameMap.AddRange(innerContext.MethodContext.VariableDefinitionToNameMap);
this.context.MethodContext.VariableNamesCollection.UnionWith(innerContext.MethodContext.VariableNamesCollection);
this.context.MethodContext.AddInnerMethodParametersToContext(innerContext.MethodContext);
this.context.MethodContext.GotoStatements.AddRange(innerContext.MethodContext.GotoStatements);
this.context.MethodContext.GotoLabels.AddRange(innerContext.MethodContext.GotoLabels);
}
ExpressionCollection expressionCollection = new ExpressionCollection();
bool hasAnonymousParameter = LambdaExpressionsHelper.HasAnonymousParameter(methodDefinition.Parameters);
foreach (ParameterDefinition parameter in methodDefinition.Parameters)
{
expressionCollection.Add(new LambdaParameterExpression(parameter, !hasAnonymousParameter, null));
}
return new LambdaExpression(expressionCollection, statement, methodDefinition.IsAsync(), methodDefinition.IsFunction(), node.Method.Parameters, false, node.MappedInstructions);
}
return base.VisitMethodReferenceExpression(node);
}
private Expression GetMethodHandleExpression(MethodReference methodReference, IEnumerable<Instruction> instructions)
{
TypeDefinition corlibTypeTypeDefinition = GetSystemTypeTypeDefinition();
string[] parametersNames = methodReference.HasParameters ? new string[] { "System.String", "System.Type[]" } : new string[] { "System.String" };
MethodReference getMethodReference = GetSystemTypeMethodReference(corlibTypeTypeDefinition, "GetMethod", parametersNames);
MethodReference getMethodHandleReference = GetHandlePropertyGetterReference(typeof(System.Reflection.MethodBase), "get_MethodHandle");
TypeOfExpression typeOfExpression = new TypeOfExpression(methodReference.DeclaringType, null);
MethodReferenceExpression getMethodMethodReferenceExpression = new MethodReferenceExpression(typeOfExpression, getMethodReference, null);
MethodInvocationExpression getMethodMethodInvocationExpression = new MethodInvocationExpression(getMethodMethodReferenceExpression, null);
LiteralExpression argument = new LiteralExpression(methodReference.Name, this.typeSystem, null);
getMethodMethodInvocationExpression.Arguments.Add(argument);
if (methodReference.HasParameters)
{
BlockExpression blockExpression = new BlockExpression(null);
foreach (ParameterDefinition parameter in methodReference.Parameters)
{
blockExpression.Expressions.Add(new TypeOfExpression(parameter.ParameterType, null));
}
InitializerExpression initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer);
ArrayCreationExpression getMethodTypeParametersArray = new ArrayCreationExpression(corlibTypeTypeDefinition, initializer, null);
getMethodTypeParametersArray.Dimensions.Add(new LiteralExpression(blockExpression.Expressions.Count, this.typeSystem, null));
getMethodMethodInvocationExpression.Arguments.Add(getMethodTypeParametersArray);
}
MethodReferenceExpression getMethodHandleMethodReferenceExpression = new MethodReferenceExpression(getMethodMethodInvocationExpression, getMethodHandleReference, null);
MethodInvocationExpression getMethodHandleMethodInvocationExpression = new MethodInvocationExpression(getMethodHandleMethodReferenceExpression, instructions);
PropertyReferenceExpression methodHandlePropertyReferenceExpression = new PropertyReferenceExpression(getMethodHandleMethodInvocationExpression, null);
return methodHandlePropertyReferenceExpression;
}
public ThisCtorExpression(MethodReferenceExpression methodReferenceExpression, IEnumerable <Instruction> instructions)
{
base(methodReferenceExpression, instructions);
return;
}
public ThisCtorExpression(MethodReferenceExpression methodReferenceExpression, IEnumerable<Instruction> instructions)
: base(methodReferenceExpression, instructions)
{
}
public MethodInvocationExpression(MethodReferenceExpression method, IEnumerable <Instruction> instructions)
: base(instructions)
{
this.MethodExpression = method;
this.Arguments = new ExpressionCollection();
}
public override void VisitMethodReferenceExpression(MethodReferenceExpression node)
{
states.Push(Step.Default);
base.VisitMethodReferenceExpression(node);
states.Pop();
}
private Expression GetTypeHandleExpression(TypeReference typeReference, IEnumerable<Instruction> instructions)
{
TypeOfExpression typeOfExpression = new TypeOfExpression(typeReference, null);
MethodReference getHandleReference = GetHandlePropertyGetterReference(typeof(Type), "get_TypeHandle");
MethodReferenceExpression getHandleReferenceExpression = new MethodReferenceExpression(typeOfExpression, getHandleReference, null);
MethodInvocationExpression methodInvoke = new MethodInvocationExpression(getHandleReferenceExpression, instructions);
return new PropertyReferenceExpression(methodInvoke, null);
}
public override void VisitMethodReferenceExpression(MethodReferenceExpression node)
{
if (node.Target != null)
{
WriteMethodTarget(node.Target);
}
else
{
WriteReferenceAndNamespaceIfInCollision(node.Method.DeclaringType);
WriteToken(".");
}
WriteMethodReference(node);
}
public virtual void VisitMethodReferenceExpression(MethodReferenceExpression node)
{
Visit(node.Target);
}
public override Expression Clone()
{
Expression targetClone = Target != null ? Target.Clone() : null;
MethodReferenceExpression result = new MethodReferenceExpression(targetClone, this.Method, this.instructions);
CopyFields(result);
return result;
}
private void CopyFields(MethodReferenceExpression clone)
{
clone.resolved = this.resolved;
clone.methodDefinition = this.methodDefinition;
clone.expressionType = this.expressionType;
}
private Expression GetFieldHandleExpression(FieldReference fieldReference, IEnumerable<Instruction> instructions)
{
TypeDefinition corlibTypeTypeDefinition = GetSystemTypeTypeDefinition();
MethodReference getFieldReference = GetSystemTypeMethodReference(corlibTypeTypeDefinition, "GetField", new string[] { "System.String" });
TypeOfExpression typeOfExpression = new TypeOfExpression(fieldReference.DeclaringType, null);
MethodReferenceExpression getFieldMethodReferenceExpression = new MethodReferenceExpression(typeOfExpression, getFieldReference, null);
MethodInvocationExpression getFieldInfoInvocation = new MethodInvocationExpression(getFieldMethodReferenceExpression, null);
getFieldInfoInvocation.Arguments.Add(new LiteralExpression(fieldReference.Name, this.typeSystem, null));
MethodReference getFieldHandleReference = GetHandlePropertyGetterReference(typeof(System.Reflection.FieldInfo), "get_FieldHandle");
MethodInvocationExpression getFieldHandleInvoke = new MethodInvocationExpression(new MethodReferenceExpression(getFieldInfoInvocation, getFieldHandleReference, null), instructions);
return new PropertyReferenceExpression(getFieldHandleInvoke, null);
}
public override void VisitMethodReferenceExpression(MethodReferenceExpression node)
{
TypesDependingOn.UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.Method.DeclaringType));
Visit(node.Target);
}
private PropertyReferenceExpression(MethodReferenceExpression methodExpression, PropertyDefinition property, bool virtualCall, IEnumerable<Instruction> instructions)
: base(methodExpression, instructions)
{
this.MethodExpression = methodExpression;
this.Property = property;
this.VirtualCall = virtualCall;
}
public override void VisitMethodReferenceExpression(MethodReferenceExpression node)
{
if (state == SearchState.Propagation)
{
canBePropagated = false;
return;
}
base.VisitMethodReferenceExpression(node);
}
public MethodInvocationExpression(MethodReferenceExpression method, IEnumerable<Instruction> instructions)
:base(instructions)
{
this.MethodExpression = method;
this.Arguments = new ExpressionCollection();
}
public override ICodeNode VisitMethodReferenceExpression(MethodReferenceExpression node)
{
node.Target = (Expression)VisitTargetExpression(node.Target);
return node;
}
private void WriteSplitPropertySetter(PropertyDefinition property)
{
WriteKeyword(KeyWordWriter.Set);
WriteBeginBlock();
WriteLine();
Indent();
MethodReferenceExpression jdSetterReference = new MethodReferenceExpression(null, property.SetMethod, null);
MethodInvocationExpression jdMethodInvocation = new MethodInvocationExpression(jdSetterReference, null);
jdMethodInvocation.Arguments = CopyMethodParametersAsArguments(property.SetMethod);
ExpressionStatement toWrite = new ExpressionStatement(jdMethodInvocation);
Write(toWrite);
WriteLine();
Outdent();
WriteEndBlock("Set");
}
protected override void WriteMethodReference(MethodReferenceExpression methodReferenceExpression)
{
MethodReference methodReference = methodReferenceExpression.Method;
string methodName = GetMethodName(methodReference);
if (methodReferenceExpression.Method is GenericInstanceMethod)
{
WriteGenericInstanceMethod(methodReference as GenericInstanceMethod);
return;
}
if (HasRefOrOutParameter(methodReferenceExpression.Method))
{
MethodDefinition md = methodReference.Resolve();
if (md == null)
{
WriteNotResolvedReference(methodName, methodReference, RefOutResolvementError);
return;
}
}
WriteReference(methodName, methodReference);
}
protected virtual void WriteMethodReference(MethodReferenceExpression methodReferenceExpression)
{
MethodReference methodReference = methodReferenceExpression.Method;
if (methodReference is GenericInstanceMethod)
{
WriteGenericInstanceMethod(methodReference as GenericInstanceMethod);
return;
}
string methodName = GetMethodName(methodReference);
WriteReference(methodName, methodReference);
}
public BaseCtorExpression(MethodReferenceExpression method, IEnumerable <Instruction> instructions) : base(method, instructions)
{
}
