public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
node.MethodExpression = (MethodReferenceExpression)Visit(node.MethodExpression);
if (status != InliningResult.NotFound)
{
return node;
}
MethodReference methodRef = node.MethodExpression.Method;
for (int i = 0; i < node.Arguments.Count; i++)
{
if (!methodRef.Parameters[i].ParameterType.IsByReference)
{
node.Arguments[i] = (Expression)Visit(node.Arguments[i]);
if (status != InliningResult.NotFound)
{
return node;
}
}
else if (valueHasSideEffects)
{
SideEffectsFinder sideEffectsFinder = new SideEffectsFinder();
if (sideEffectsFinder.HasSideEffectsRecursive(node.Arguments[i]))
{
status = InliningResult.Abort;
return node;
}
}
}
return node;
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
Expression methodTarget = node.GetTarget();
if (methodTarget != null)
{
if (methodTarget.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
VariableReference variable = (methodTarget as VariableReferenceExpression).Variable;
if (this.variableToReplacingExpressionMap.ContainsKey(variable))
{
this.variablesToNotInline.Add(variable);
}
}
else if (methodTarget.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition field = (methodTarget as FieldReferenceExpression).Field.Resolve();
if (this.fieldToReplacingExpressionMap.ContainsKey(field))
{
VariableReference variableToNotInline = (this.fieldToReplacingExpressionMap[field] as VariableReferenceExpression).Variable;
this.variablesToNotInline.Add(variableToNotInline);
}
}
}
return base.VisitMethodInvocationExpression(node);
}
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (!(node.MethodExpression is MethodReferenceExpression))
{
return null;
}
MethodReferenceExpression methodReferenceExpression = node.MethodExpression;
MethodReference methodReference = methodReferenceExpression.Method;
if (methodReference.Name == null)
{
return null;
}
string eventMethodPrefix = GetEventMethodPrefix(methodReference.Name);
if (string.IsNullOrEmpty(eventMethodPrefix))
{
return null;
}
if (methodReference.Parameters.Count != 1)
{
return null;
}
TypeReference typeReference = methodReference.DeclaringType;
EventDefinition targetEvent = null;
do
{
if (typeReference == null)
{
break;
}
TypeDefinition typeDefinition = typeReference.Resolve();
if (typeDefinition == null)
{
break;
}
string eventName = methodReference.Name.Substring(eventMethodPrefix.Length);
targetEvent = typeDefinition.Events.FirstOrDefault(e => e.Name == eventName);
if (targetEvent == null)
{
typeReference = typeDefinition.BaseType;
}
} while (typeReference != null && targetEvent == null);
if (targetEvent == null)
{
return null;
}
EventReferenceExpression target = new EventReferenceExpression(methodReferenceExpression.Target, targetEvent, null);
return GetEventAssignExpression(target, node.Arguments[0], eventMethodPrefix, node.InvocationInstructions);
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
base.VisitMethodInvocationExpression(node);
FixArguments(node.MethodExpression.Method, node.Arguments);
return node;
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
base.VisitMethodInvocationExpression(node);
if (node.MethodExpression.CodeNodeType == CodeNodeType.MethodReferenceExpression)
{
FixArguments(node.MethodExpression.Method, node.Arguments);
}
}
public MethodSpecificContext(MethodBody body,
Dictionary<VariableDefinition, string> variableDefinitionToNameMap, Dictionary<ParameterDefinition, string> parameterDefinitionTonameMap,
MethodInvocationExpression ctorInvokeExpression)
: this(body)
{
this.VariableDefinitionToNameMap = variableDefinitionToNameMap;
this.ParameterDefinitionToNameMap = parameterDefinitionTonameMap;
this.CtorInvokeExpression = ctorInvokeExpression;
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
LinqQueryExpression result;
if (TryMatchLinqQuery(node, out result))
{
return RemoveTransparentIdentifiers(result);
}
return base.VisitMethodInvocationExpression(node);
}
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
MethodReferenceExpression methodReference = node.MethodExpression;
if ((methodReference == null) ||
(methodReference.Method.CallingConvention == MethodCallingConvention.StdCall))
{
return null;
}
MethodReference method = methodReference.Method;
BinaryOperator binaryOperator;
if (binaryOperators.TryGetValue (method.Name, out binaryOperator))
{
return BuildBinaryExpression(binaryOperator, node.Arguments[0], node.Arguments[1], method.FixedReturnType, node.InvocationInstructions);
}
UnaryOperator unaryOperator;
if (unaryOperators.TryGetValue (method.Name, out unaryOperator))
{
return BuildUnaryExpression(unaryOperator, node.Arguments[0], node.InvocationInstructions);
}
if(method.Name == "op_True")
{
return (Expression)codeTransformer.Visit(node.Arguments[0]);
}
else if(method.Name == "op_False")
{
//TODO: Must consider better representation
return new ConditionExpression((Expression)codeTransformer.Visit(node.Arguments[0]),
new LiteralExpression(false, typeSystem, null), new LiteralExpression(true, typeSystem, null), node.InvocationInstructions);
}
if (method.Name == "op_Explicit")
{
return new CastExpression((Expression)codeTransformer.Visit(node.Arguments[0]), node.ExpressionType, node.InvocationInstructions);
}
if (method.Name == "op_Implicit")
{
return codeTransformer.Visit(node.Arguments[0]);
}
if (method.Name == "get_Chars" && node.MethodExpression.Target.ExpressionType.FullName == "System.String")
{
ArrayIndexerExpression stringIndexing = new ArrayIndexerExpression(node.MethodExpression.Target, node.InvocationInstructions);
foreach (Expression arg in node.Arguments)
{
stringIndexing.Indices.Add(arg);
}
return stringIndexing;
}
return null;
}
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
TypeReference typeReference;
if (!node.IsTypeOfExpression(out typeReference))
{
return null;
}
return new TypeOfExpression (typeReference, node.UnderlyingSameMethodInstructions);
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
ICodeNode newNode = typeOfStep.VisitMethodInvocationExpression(node);
if (newNode != null)
{
return newNode;
}
replaceThisWithBaseStep.VisitMethodInvocationExpression(node);
newNode = operatorStep.VisitMethodInvocationExpression(node);
if (newNode != null)
{
return base.Visit(newNode);
}
newNode = replaceDelegateInvokeStep.VisitMethodInvocationExpression(node);
if (newNode != null)
{
return base.VisitDelegateInvokeExpression(newNode as DelegateInvokeExpression);
}
newNode = propertyRecognizer.VisitMethodInvocationExpression(node);
if (newNode != null)
{
PropertyReferenceExpression propertyReference = newNode as PropertyReferenceExpression;
if (propertyReference != null) // if it was a getter
{
newNode = this.VisitPropertyReferenceExpression(propertyReference);
}
if (newNode is BinaryExpression) // if it was a setter
{
newNode = this.VisitBinaryExpression(newNode as BinaryExpression);
}
return newNode;
}
newNode = rebuildEventsStep.VisitMethodInvocationExpression(node);
if (newNode != null)
{
if (newNode is BinaryExpression)
{
return VisitBinaryExpression(newNode as BinaryExpression);
}
return newNode;
}
return base.VisitMethodInvocationExpression(node);
}
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.MethodExpression.CodeNodeType == CodeNodeType.MethodReferenceExpression)
{
MethodReferenceExpression methodReferenceExpression = node.MethodExpression;
MethodReference methodReference = methodReferenceExpression.Method;
if (IsDelegateInvokeMethod(methodReference))
{
ExpressionCollection visitedArguments = (ExpressionCollection)codeTransformer.Visit(node.Arguments);
return new DelegateInvokeExpression(methodReferenceExpression.Target, visitedArguments, methodReference, node.InvocationInstructions);
}
}
return null;
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
Visit(node.MethodExpression);
if (node.MethodExpression is MethodReferenceExpression)
{
this.methodInvocationsStackCount++;
}
Visit(node.Arguments);
if (node.MethodExpression is MethodReferenceExpression)
{
this.methodInvocationsStackCount--;
}
}
internal MethodSpecificContext(DecompilationAnalysisResults analysisResults, YieldData yieldData, AsyncData asyncData,
bool isMethodBodyChanged, Dictionary<string, Statement> gotoLabels, List<GotoStatement> gotoStatements,
StackUsageData stackData, bool isBaseConstructorInvokingConstructor, bool enableEventAnalysis,
MethodBody body, Collection<VariableDefinition> variables, ControlFlowGraph controlFlowGraph,
ExpressionDecompilerData expressions, BlockLogicalConstruct logicalConstructsTree, LogicalFlowBuilderContext logicalConstructsContext,
MethodInvocationExpression ctorInvokeExpression, Dictionary<Statement, ILogicalConstruct> statementToLogicalConstruct,
Dictionary<ILogicalConstruct, List<Statement>> logicalConstructToStatements, Dictionary<VariableDefinition, string> variableDefinitionToNameMap,
HashSet<string> variableNamesCollection, Dictionary<ParameterDefinition, string> parameterDefinitionToNameMap,
HashSet<VariableDefinition> variablesToRename, Dictionary<FieldDefinition, Expression> fieldToExpression,
int lambdaVariablesCount, Dictionary<VariableDefinition, AssignmentType> variableAssignmentData, List<ParameterDefinition> outParametersToAssign,
bool isDestructor, BlockStatement destructorStatements, HashSet<VariableDefinition> undeclaredLinqVariables,
Dictionary<VariableReference, Dictionary<FieldDefinition, Expression>> closureVariableToFieldValue,
HashSet<VariableDefinition> variablesToNotDeclare)
{
this.AnalysisResults = analysisResults;
this.YieldData = yieldData;
this.AsyncData = asyncData;
this.IsMethodBodyChanged = isMethodBodyChanged;
this.GotoLabels = gotoLabels;
this.GotoStatements = gotoStatements;
this.StackData = stackData;
this.IsBaseConstructorInvokingConstructor = isBaseConstructorInvokingConstructor;
this.EnableEventAnalysis = enableEventAnalysis;
this.Body = body;
this.Variables = variables;
this.ControlFlowGraph = controlFlowGraph;
this.Expressions = expressions;
this.LogicalConstructsTree = logicalConstructsTree;
this.LogicalConstructsContext = logicalConstructsContext;
this.CtorInvokeExpression = ctorInvokeExpression;
this.StatementToLogicalConstruct = statementToLogicalConstruct;
this.LogicalConstructToStatements = logicalConstructToStatements;
this.VariableDefinitionToNameMap = variableDefinitionToNameMap;
this.VariableNamesCollection = variableNamesCollection;
this.ParameterDefinitionToNameMap = parameterDefinitionToNameMap;
this.VariablesToRename = variablesToRename;
this.FieldToExpression = fieldToExpression;
this.LambdaVariablesCount = lambdaVariablesCount;
this.VariableAssignmentData = variableAssignmentData;
this.OutParametersToAssign = outParametersToAssign;
this.IsDestructor = isDestructor;
this.DestructorStatements = destructorStatements;
this.UndeclaredLinqVariables = undeclaredLinqVariables;
this.ClosureVariableToFieldValue = closureVariableToFieldValue;
this.VariablesToNotDeclare = variablesToNotDeclare;
}
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
MethodReferenceExpression methodRef = node.MethodExpression;
if (methodRef == null)
{
return null;
}
MethodDefinition method = methodRef.Method as MethodDefinition;
//// must be resolved.
if (method == null)
{
MethodReference methodReference = methodRef.Method;
if (methodReference != null
&& !string.IsNullOrEmpty(methodReference.Name)
&& (methodReference.Name.StartsWith("set_") || methodReference.Name.StartsWith("get_") || methodReference.Name.StartsWith("put_") /*Setter prefix in winrt*/))
{
method = methodReference.Resolve();
}
}
if (method != null)
{
if (method.IsGetter || method.IsSetter)
{
PropertyReferenceExpression propExpr = new PropertyReferenceExpression(node, null);
if (propExpr.Property == null)
{
// sanity check - if the method is resolved and is determined to be getter/setter, then a
// property record should be available.
return node;
}
Expression result = propExpr;
if (method.IsSetter)
{
int last = node.Arguments.Count - 1;
result = new BinaryExpression(BinaryOperator.Assign, propExpr, node.Arguments[last], typeSystem, null);
}
return result;
}
}
return null;
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
Expression visitedExpression = (Expression)base.VisitMethodInvocationExpression(node);
MethodInvocationExpression methodInvocation = visitedExpression as MethodInvocationExpression;
if (methodInvocation != null && methodInvocation.MethodExpression.Target != null && methodInvocation.MethodExpression.Method.Name == "Invoke")
{
if (methodInvocation.MethodExpression.Target.CodeNodeType == CodeNodeType.FieldReferenceExpression &&
(methodInvocation.MethodExpression.Target as FieldReferenceExpression).Field.Name == "Target" &&
(methodInvocation.MethodExpression.Target as FieldReferenceExpression).Target != null &&
(methodInvocation.MethodExpression.Target as FieldReferenceExpression).Target.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition fieldDef = ((methodInvocation.MethodExpression.Target as FieldReferenceExpression).Target as FieldReferenceExpression).Field.Resolve();
CallSiteInfo callSiteInfo;
if (fieldDef != null && fieldToCallSiteInfoMap.TryGetValue(fieldDef, out callSiteInfo))
{
if (callSiteInfo.BinderType != CallSiteBinderType.IsEvent)
{
return GenerateExpression(callSiteInfo, methodInvocation.Arguments, methodInvocation.InvocationInstructions);
}
else
{
isEventIfStatements.Add(closestIf, methodInvocation);
}
}
}
else if (methodInvocation.MethodExpression.Target.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
VariableReference varRef = (methodInvocation.MethodExpression.Target as VariableReferenceExpression).Variable;
CallSiteInfo callSiteInfo;
if (variableToCallSiteInfoMap.TryGetValue(varRef, out callSiteInfo))
{
if (callSiteInfo.BinderType != CallSiteBinderType.IsEvent)
{
return GenerateExpression(callSiteInfo, methodInvocation.Arguments, methodInvocation.InvocationInstructions);
}
else
{
isEventIfStatements.Add(closestIf, methodInvocation);
}
}
}
}
return visitedExpression;
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
node = (MethodInvocationExpression)base.VisitMethodInvocationExpression(node);
VisitInvocationArguments(node.Arguments, node.MethodExpression.Method);
if (node.IsConstrained)
{
if (node.MethodExpression.Target.CodeNodeType == CodeNodeType.LiteralExpression)
{
TypeDefinition constraintTypeDef = node.ConstraintType.Resolve();
if (constraintTypeDef.IsEnum)
{
node.MethodExpression.Target = EnumHelper.GetEnumExpression(constraintTypeDef, node.MethodExpression.Target as LiteralExpression, typeSystem);
}
}
}
return node;
}
private bool TryMatchLinqQuery(MethodInvocationExpression methodInvocation, out LinqQueryExpression linqQuery)
{
Stack<MethodInvocationExpression> queryStack = new Stack<MethodInvocationExpression>();
MethodInvocationExpression current = methodInvocation;
bool isQueryableMethod = current.MethodExpression.MethodDefinition.IsQueryableMethod();
while (current != null && current.MethodExpression.MethodDefinition.IsQueryMethod() && isQueryableMethod == current.MethodExpression.MethodDefinition.IsQueryableMethod())
{
queryStack.Push(current);
current = current.Arguments[0] as MethodInvocationExpression;
}
if (queryStack.Count == 0)
{
linqQuery = null;
return false;
}
MethodInvocationExpression top = queryStack.Peek();
top.Arguments[0] = (Expression)Visit(top.Arguments[0]);
linqQuery = ProcessExtensionMethodChain(queryStack, methodInvocation, isQueryableMethod);
return linqQuery != null;
}
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 override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (IsGetCurrent(node))
{
ResultingType = node.ExpressionType;
}
base.VisitMethodInvocationExpression(node);
}
private bool IsMoveNextCall(MethodInvocationExpression invocation)
{
if (invocation == null)
{
return false;
}
if (invocation.MethodExpression.Method.Name == "MoveNext")
{
VariableReferenceExpression target = invocation.MethodExpression.Target as VariableReferenceExpression;
if (target != null)
{
if (target.Variable == theEnumerator)
{
return true;
}
}
}
return false;
}
private bool IsGetEnumerator(MethodInvocationExpression supposedGetEnumerator)
{
if (supposedGetEnumerator.MethodExpression.Method.Name != "GetEnumerator")
{
return false;
}
if (supposedGetEnumerator.MethodExpression.Target == null)
{
return false;
}
this.foreachCollection = supposedGetEnumerator.MethodExpression.Target;
return true;
}
private bool IsEnumeratorDispose(MethodInvocationExpression methodInvocationExpression)
{
if (methodInvocationExpression == null)
{
return false;
}
if (methodInvocationExpression.MethodExpression.Method.Name == "Dispose")
{
return true;
}
return false;
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (!foundWhile && (IsGetCurrent(node) || IsMoveNextCall(node)))
{
ClearState();
}
else
{
if (IsGetCurrent(node))
{
foreachVariableType = node.ExpressionType;
}
}
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
bool isExtentionMethod = false;
if (node.MethodExpression.CodeNodeType == CodeNodeType.MethodReferenceExpression)
{
MethodReferenceExpression methodReference = node.MethodExpression;
MethodReference method = methodReference.Method;
if (method != null)
{
// performance : must be static and do not use method.Resolve that resolves the whole graph.
if (!method.HasThis && methodReference.MethodDefinition != null)
{
isExtentionMethod = methodReference.MethodDefinition.IsExtensionMethod;
}
}
}
if (isExtentionMethod)
{
// TODO: This shouldn't happen but fact is it happens. Seems like some other issue that needs fixing.
if (node.Arguments.Count > 0)
{
ProcessExtensionMethod(node.MethodExpression.Method);
WriteMethodTarget(node.Arguments[0]);
}
}
else
{
if (node.MethodExpression.Target != null)
{
WriteMethodTarget(node.MethodExpression.Target);
}
if (!node.MethodExpression.Method.HasThis)
{
if (node.MethodExpression.MethodDefinition != null && !node.MethodExpression.MethodDefinition.IsExtensionMethod || node.MethodExpression.MethodDefinition == null)
{
WriteReferenceAndNamespaceIfInCollision(node.MethodExpression.Method.DeclaringType);
WriteToken(".");
}
}
}
WriteMethodReference(node.MethodExpression);
//VisitMethodReferenceExpression(node.MethodExpression);
bool indexProp = false;
WriteToken(indexProp ? IndexLeftBracket : "(");
if (node.MethodExpression is MethodReferenceExpression)
{
EnterMethodInvocation(node.MethodExpression.Method);
if (!isExtentionMethod)
{
VisitMethodParameters(node.Arguments);
}
else
{
VisitExtensionMethodParameters(node.Arguments);
}
LeaveMethodInvocation();
}
else
{
VisitMethodParameters(node.Arguments);
}
WriteToken(indexProp ? IndexRightBracket : ")");
}
protected virtual void WriteBaseConstructorInvokation(MethodInvocationExpression baseConstructorInvokation)
{
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
base.VisitMethodInvocationExpression(node);
CastMethodArguments(node.MethodExpression.Method, node.Arguments);
}
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.MethodExpression.Target is VariableReferenceExpression)
{
if ((node.MethodExpression.Target as VariableReferenceExpression).Variable == enumerator)
{
if (node.MethodExpression.Method.Name == "get_Current")
{
return new VariableReferenceExpression(foreachVariable, null);
}
}
}
return base.VisitMethodInvocationExpression(node);
}
public void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.VirtualCall)
{
//Targets of virtual method calls should not be changed
MethodReferenceExpression method = node.MethodExpression;
if (!method.Target.HasType)
{
/// The target expression has no type.
/// This will result in bad navigation when clicking in the produced method call.
return;
}
if (method.Target.ExpressionType.FullName == method.Method.DeclaringType.FullName)
{
return;
}
MethodReference overridingMethod = method.Method;
TypeDefinition targetType = method.Target.ExpressionType.Resolve();
if (targetType == null)
{
// Generics
return;
}
List<TypeDefinition> inheritanceChain = GetInheritanceChain(targetType, method.Method.DeclaringType.FullName);
foreach (TypeDefinition type in inheritanceChain)
{
MethodDefinition overrider = type.Methods.FirstOrDefault(x => x.Name == method.Method.Name && x.HasSameSignatureWith(method.Method));
if (overrider != null)
{
overridingMethod = overrider;
}
}
node.MethodExpression = new MethodReferenceExpression(node.MethodExpression.Target, overridingMethod, node.MethodExpression.MappedInstructions);
return;
}
MethodReferenceExpression methodReferenceExpression = node.MethodExpression;
if (methodReferenceExpression == null)
{
return;
}
if (methodReferenceExpression.Target is ThisReferenceExpression)
{
TypeDefinition decompiledMethodDeclaringType = baseCodeTransformer.Method.DeclaringType.Resolve();
if (decompiledMethodDeclaringType != null &&
decompiledMethodDeclaringType != methodReferenceExpression.Method.DeclaringType.Resolve())
{
TypeReference baseType = baseCodeTransformer.Method.DeclaringType.BaseType;
// does not have a base class.
if (baseType == null || baseType.FullName == typeof(System.Object).FullName)
{
return;
}
methodReferenceExpression.Target = new BaseReferenceExpression(methodReferenceExpression.Method.DeclaringType,
(methodReferenceExpression.Target as ThisReferenceExpression).MappedInstructions);
}
}
}
public override void VisitMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.MethodExpression.Target is VariableReferenceExpression)
{
if ((node.MethodExpression.Target as VariableReferenceExpression).Variable == enumerator)
{
if (node.MethodExpression.Method.Name != "get_Current")
{
IsEnumeratorUsed = true;
}
}
}
base.VisitMethodInvocationExpression(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");
}