public override ICodeNode VisitLambdaExpression(LambdaExpression node) { // Visit of lambdas is needed only when locating declarations. if (this.state == State.LocateDeclarations) { // The following visit of the body of the lambda expression is needed, because variables that are declared in the // containing method, may be used in it. The clone is needed, because the lambda expression is already visited // and processed, and the only thing we need is to visit the variable references in it. Visit((node.CloneExpressionOnly() as LambdaExpression).Body); } return node; }
public override void VisitLambdaExpression(LambdaExpression node) { if (node.IsAsync && KeyWordWriter.Async != null) { WriteKeyword(KeyWordWriter.Async); WriteSpace(); } }
public override void VisitLambdaExpression(LambdaExpression node) { base.VisitLambdaExpression(node); string lambdaMethodKeyword = node.IsFunction ? KeyWordWriter.Function : KeyWordWriter.Sub; WriteKeyword(lambdaMethodKeyword); WriteToken("("); VisitMethodParameters(node.Arguments); WriteToken(")"); bool isShortFormLambda = false; bool newLineAfterStatemtentsWritten; if (node.Body.Statements.Count == 1) { if (node.Body.Statements[0].CodeNodeType == CodeNodeType.ExpressionStatement) { isShortFormLambda = true; ShouldOmitSemicolon.Push(true); } else { ShouldOmitSemicolon.Push(false); } if (isShortFormLambda) { WriteSpace(); } else { WriteLine(); } Visit(node.Body.Statements[0]); newLineAfterStatemtentsWritten = false; } else { ShouldOmitSemicolon.Push(false); WriteLine(); Visit(node.Body); newLineAfterStatemtentsWritten = true; } if (!isShortFormLambda) { if (!newLineAfterStatemtentsWritten) { WriteLine(); } WriteEndBlock(lambdaMethodKeyword); } ShouldOmitSemicolon.Pop(); }
public override ICodeNode VisitLambdaExpression(LambdaExpression node) { return node.IsExpressionTreeLambda ? node : base.VisitLambdaExpression(node); }
public override void VisitLambdaExpression(LambdaExpression node) { base.VisitLambdaExpression(node); WriteToken("("); VisitMethodParameters(node.Arguments); WriteToken(")"); WriteSpace(); WriteToken("=>"); WriteSpace(); if (node.Body.Statements.Count == 1) { if (node.Body.Statements[0].CodeNodeType == CodeNodeType.ExpressionStatement) { ShouldOmitSemicolon.Push(true); Visit(node.Body.Statements[0] as ExpressionStatement); } else { ShouldOmitSemicolon.Push(false); Visit(node.Body); } } else { ShouldOmitSemicolon.Push(false); Visit(node.Body); } ShouldOmitSemicolon.Pop(); }
public override void VisitLambdaExpression(LambdaExpression node) { inLambdaCount++; base.VisitLambdaExpression(node); inLambdaCount--; return; }
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 virtual void VisitLambdaExpression(LambdaExpression node) { Visit(node.Body); }
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 void VisitLambdaExpression(LambdaExpression node) { if (state == SearchState.Propagation) { canBePropagated = false; return; } base.VisitLambdaExpression(node); }
public override Expression CloneExpressionOnly() { LambdaExpression result = new LambdaExpression(Arguments.CloneExpressionsOnly(), Body.CloneStatementOnly() as BlockStatement, IsAsync, IsFunction, Parameters, this.IsExpressionTreeLambda, null) { ExpressionType = this.ExpressionType }; return result; }