private Expression ProcessReturnExpression(LambdaExpression lambdaExpression, VariableReference[] identifiers)
            {
                if (lambdaExpression.Arguments.Count != identifiers.Length || lambdaExpression.Body.Statements.Count != 1 ||
                    lambdaExpression.Body.Statements[0].CodeNodeType != CodeNodeType.ExpressionStatement)
                {
                    return(null);
                }

                ShortFormReturnExpression returnExpression = (lambdaExpression.Body.Statements[0] as ExpressionStatement).Expression as ShortFormReturnExpression;

                if (returnExpression == null)
                {
                    return(null);
                }

                Dictionary <ParameterDefinition, VariableReference> parameterToIdentifierMap = new Dictionary <ParameterDefinition, VariableReference>();

                for (int i = 0; i < identifiers.Length; i++)
                {
                    parameterToIdentifierMap[lambdaExpression.Parameters[i].Resolve()] = identifiers[i];
                }

                Expression result = returnExpression.Value.CloneAndAttachInstructions(returnExpression.MappedInstructions);

                result = (Expression) new IdentifierReplacer(parameterToIdentifierMap).Visit(result);

                return(result);
            }
            public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
            {
                if (state == State.ReplaceDelegate && node.Arguments != null && node.Arguments.Count == 2 &&
                    node.Arguments[0].CodeNodeType == CodeNodeType.VariableReferenceExpression &&
                    node.Arguments[1].CodeNodeType == CodeNodeType.MethodReferenceExpression &&
                    delegateCopies.Contains((node.Arguments[0] as VariableReferenceExpression).Variable))
                {
                    //final check inserted here for optimization
                    TypeDefinition objectType = node.Constructor.DeclaringType.Resolve();
                    if (objectType == null || objectType.BaseType == null || objectType.BaseType.FullName != "System.MulticastDelegate")
                    {
                        return(base.VisitObjectCreationExpression(node));
                    }

                    MethodReference  methodReference  = (node.Arguments[1] as MethodReferenceExpression).Method;
                    MethodDefinition methodDefinition = (node.Arguments[1] as MethodReferenceExpression).MethodDefinition;

                    MethodSpecificContext delegateMethodContext = new MethodSpecificContext(methodDefinition.Body);
                    DecompilationContext  innerContext          = new DecompilationContext(delegateMethodContext, context.TypeContext, context.ModuleContext, context.AssemblyContext);
                    delegateMethodContext.FieldToExpression = fieldDefToAssignedValueMap;

                    BlockStatement methodStatements = methodDefinition.Body.DecompileLambda(Language, innerContext);

                    if ((methodStatements.Statements.Count == 1) && (methodStatements.Statements[0].CodeNodeType == CodeNodeType.ExpressionStatement) &&
                        ((methodStatements.Statements[0] as ExpressionStatement).Expression.CodeNodeType == CodeNodeType.ReturnExpression))
                    {
                        ReturnExpression          returnExpression          = (methodStatements.Statements[0] as ExpressionStatement).Expression as ReturnExpression;
                        ShortFormReturnExpression shortFormReturnExpression = new ShortFormReturnExpression(returnExpression.Value, returnExpression.MappedInstructions);
                        methodStatements = new BlockStatement();
                        methodStatements.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 hasAnonymousParamterer = LambdaExpressionsHelper.HasAnonymousParameter(methodDefinition.Parameters);
                    foreach (ParameterDefinition parameter in methodDefinition.Parameters)
                    {
                        expressionCollection.Add(new LambdaParameterExpression(parameter, !hasAnonymousParamterer, null));
                    }

                    delegatesFound.Add(methodStatements);

                    LambdaExpression lambdaExpression =
                        new LambdaExpression(expressionCollection, methodStatements, methodDefinition.IsAsync(), methodDefinition.IsFunction(), methodReference.Parameters, false,
                                             node.Arguments[1].MappedInstructions)
                    {
                        ExpressionType = objectType
                    };

                    DelegateCreationExpression result = new DelegateCreationExpression(node.Constructor.DeclaringType, lambdaExpression, node.Arguments[0], node.MappedInstructions);
                    return(result);
                }

                return(base.VisitObjectCreationExpression(node));
            }
 public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
 {
     if (this.state != 2 || node.get_Arguments() == null || node.get_Arguments().get_Count() != 2 || node.get_Arguments().get_Item(0).get_CodeNodeType() != 26 || node.get_Arguments().get_Item(1).get_CodeNodeType() != 20 || !this.delegateCopies.Contains((node.get_Arguments().get_Item(0) as VariableReferenceExpression).get_Variable()))
     {
         return(this.VisitObjectCreationExpression(node));
     }
     V_0 = node.get_Constructor().get_DeclaringType().Resolve();
     if (V_0 == null || V_0.get_BaseType() == null || String.op_Inequality(V_0.get_BaseType().get_FullName(), "System.MulticastDelegate"))
     {
         return(this.VisitObjectCreationExpression(node));
     }
     V_1             = (node.get_Arguments().get_Item(1) as MethodReferenceExpression).get_Method();
     V_2             = (node.get_Arguments().get_Item(1) as MethodReferenceExpression).get_MethodDefinition();
     stackVariable62 = new MethodSpecificContext(V_2.get_Body());
     V_3             = new DecompilationContext(stackVariable62, this.context.get_TypeContext(), this.context.get_ModuleContext(), this.context.get_AssemblyContext(), this.context.get_Language());
     stackVariable62.set_FieldToExpression(this.fieldDefToAssignedValueMap);
     V_4 = V_2.get_Body().DecompileLambda(this.context.get_Language(), V_3);
     if (V_4.get_Statements().get_Count() == 1 && V_4.get_Statements().get_Item(0).get_CodeNodeType() == 5 && (V_4.get_Statements().get_Item(0) as ExpressionStatement).get_Expression().get_CodeNodeType() == 57)
     {
         V_8 = (V_4.get_Statements().get_Item(0) as ExpressionStatement).get_Expression() as ReturnExpression;
         V_9 = new ShortFormReturnExpression(V_8.get_Value(), V_8.get_MappedInstructions());
         V_4 = new BlockStatement();
         V_4.get_Statements().Add(new ExpressionStatement(V_9));
     }
     this.context.get_MethodContext().get_VariableDefinitionToNameMap().AddRange <VariableDefinition, string>(V_3.get_MethodContext().get_VariableDefinitionToNameMap());
     this.context.get_MethodContext().get_VariableNamesCollection().UnionWith(V_3.get_MethodContext().get_VariableNamesCollection());
     this.context.get_MethodContext().AddInnerMethodParametersToContext(V_3.get_MethodContext());
     this.context.get_MethodContext().get_GotoStatements().AddRange(V_3.get_MethodContext().get_GotoStatements());
     this.context.get_MethodContext().get_GotoLabels().AddRange <string, Statement>(V_3.get_MethodContext().get_GotoLabels());
     V_5  = new ExpressionCollection();
     V_6  = LambdaExpressionsHelper.HasAnonymousParameter(V_2.get_Parameters());
     V_10 = V_2.get_Parameters().GetEnumerator();
     try
     {
         while (V_10.MoveNext())
         {
             V_11 = V_10.get_Current();
             V_5.Add(new LambdaParameterExpression(V_11, !V_6, null));
         }
     }
     finally
     {
         V_10.Dispose();
     }
     this.delegatesFound.Add(V_4);
     stackVariable157 = new LambdaExpression(V_5, V_4, V_2.IsAsync(), V_2.IsFunction(), V_1.get_Parameters(), false, node.get_Arguments().get_Item(1).get_MappedInstructions());
     stackVariable157.set_ExpressionType(V_0);
     V_7 = stackVariable157;
     return(new DelegateCreationExpression(node.get_Constructor().get_DeclaringType(), V_7, node.get_Arguments().get_Item(0), node.get_MappedInstructions()));
 }
Пример #4
0
 public override ICodeNode VisitMethodReferenceExpression(MethodReferenceExpression node)
 {
     V_0 = node.get_Method().Resolve();
     V_1 = this.context.get_TypeContext().get_CurrentType();
     if (V_0 == null || (object)V_0.get_DeclaringType() != (object)V_1 && !V_0.get_DeclaringType().IsNestedIn(V_1))
     {
         return(this.VisitMethodReferenceExpression(node));
     }
     if (V_0.get_IsGetter() || V_0.get_IsSetter() || !V_0.IsCompilerGenerated(true) && !this.CheckTypeForCompilerGeneratedAttribute(V_0.get_DeclaringType()))
     {
         return(this.VisitMethodReferenceExpression(node));
     }
     V_2 = null;
     if (V_0.get_Body() != null)
     {
         V_5 = this.CreateDecompilationContext(V_0);
         V_2 = V_0.get_Body().DecompileLambda(this.context.get_Language(), V_5);
         if (V_2.get_Statements().get_Count() == 1 && V_2.get_Statements().get_Item(0).get_CodeNodeType() == 5 && (V_2.get_Statements().get_Item(0) as ExpressionStatement).get_Expression().get_CodeNodeType() == 57)
         {
             V_6 = (V_2.get_Statements().get_Item(0) as ExpressionStatement).get_Expression() as ReturnExpression;
             V_7 = new ShortFormReturnExpression(V_6.get_Value(), V_6.get_MappedInstructions());
             V_2 = new BlockStatement();
             V_2.get_Statements().Add(new ExpressionStatement(V_7));
         }
         this.context.get_MethodContext().get_VariableDefinitionToNameMap().AddRange <VariableDefinition, string>(V_5.get_MethodContext().get_VariableDefinitionToNameMap());
         this.context.get_MethodContext().get_VariableNamesCollection().UnionWith(V_5.get_MethodContext().get_VariableNamesCollection());
         this.context.get_MethodContext().AddInnerMethodParametersToContext(V_5.get_MethodContext());
         this.context.get_MethodContext().get_GotoStatements().AddRange(V_5.get_MethodContext().get_GotoStatements());
         this.context.get_MethodContext().get_GotoLabels().AddRange <string, Statement>(V_5.get_MethodContext().get_GotoLabels());
     }
     V_3 = new ExpressionCollection();
     V_4 = LambdaExpressionsHelper.HasAnonymousParameter(V_0.get_Parameters());
     V_8 = V_0.get_Parameters().GetEnumerator();
     try
     {
         while (V_8.MoveNext())
         {
             V_9 = V_8.get_Current();
             V_3.Add(new LambdaParameterExpression(V_9, !V_4, null));
         }
     }
     finally
     {
         V_8.Dispose();
     }
     return(new LambdaExpression(V_3, V_2, V_0.IsAsync(), V_0.IsFunction(), node.get_Method().get_Parameters(), false, node.get_MappedInstructions()));
 }
        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(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));
        }
Пример #6
0
 public virtual void VisitShortFormReturnExpression(ShortFormReturnExpression node)
 {
     Visit(node.Value);
 }
Пример #7
0
 public virtual ICodeNode VisitShortFormReturnExpression(ShortFormReturnExpression node)
 {
     node.Value = (Expression)Visit(node.Value);
     return(node);
 }
Пример #8
0
 public virtual void VisitShortFormReturnExpression(ShortFormReturnExpression node)
 {
     this.Visit(node.get_Value());
     return;
 }
 public virtual ICodeNode VisitShortFormReturnExpression(ShortFormReturnExpression node)
 {
     node.set_Value((Expression)this.Visit(node.get_Value()));
     return(node);
 }