public static bool TryCreate(LambdaExpressionSyntax lambdaExpression, out LambdaExpressionWithSingleParameter result) { switch (lambdaExpression?.Kind()) { case SyntaxKind.SimpleLambdaExpression: { var simpleLambda = (SimpleLambdaExpressionSyntax)lambdaExpression; result = new LambdaExpressionWithSingleParameter(simpleLambda.Parameter, simpleLambda.Body); return(true); } case SyntaxKind.ParenthesizedLambdaExpression: { var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)lambdaExpression; ParameterListSyntax parameterList = parenthesizedLambda.ParameterList; if (parameterList != null) { SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters; if (parameters.Count == 1) { result = new LambdaExpressionWithSingleParameter(parameters[0], parenthesizedLambda.Body); return(true); } } break; } } result = default(LambdaExpressionWithSingleParameter); return(false); }
internal static SingleParameterLambdaExpressionInfo CreateCore( LambdaExpressionSyntax lambdaExpression, bool allowMissing = false) { switch (lambdaExpression?.Kind()) { case SyntaxKind.SimpleLambdaExpression: { var simpleLambda = (SimpleLambdaExpressionSyntax)lambdaExpression; ParameterSyntax parameter = simpleLambda.Parameter; if (!Check(parameter, allowMissing)) { break; } CSharpSyntaxNode body = simpleLambda.Body; if (!Check(body, allowMissing)) { break; } return(new SingleParameterLambdaExpressionInfo(simpleLambda, parameter, body)); } case SyntaxKind.ParenthesizedLambdaExpression: { var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)lambdaExpression; ParameterSyntax parameter = parenthesizedLambda .ParameterList? .Parameters .SingleOrDefault(shouldthrow: false); if (!Check(parameter, allowMissing)) { break; } CSharpSyntaxNode body = parenthesizedLambda.Body; if (!Check(body, allowMissing)) { break; } return(new SingleParameterLambdaExpressionInfo(parenthesizedLambda, parameter, body)); } } return(Default); }
private static bool TryConvertToExpressionBody( LambdaExpressionSyntax declaration, ParseOptions options, ExpressionBodyPreference conversionPreference, out ExpressionSyntax expression, out SyntaxToken semicolon) { var body = declaration.Body as BlockSyntax; return(body.TryConvertToExpressionBody( declaration.Kind(), options, conversionPreference, out expression, out semicolon)); }
public static async Task <Document> RefactorAsync( Document document, LambdaExpressionSyntax lambda, ExpressionSyntax expression, CancellationToken cancellationToken = default(CancellationToken)) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var methodSymbol = (IMethodSymbol)semanticModel.GetSymbol(lambda, cancellationToken); StatementSyntax statement; if (ShouldCreateExpressionStatement(expression, methodSymbol)) { statement = ExpressionStatement(expression); } else { statement = ReturnStatement(expression); } BlockSyntax block = Block(statement); block = block .WithCloseBraceToken( block.CloseBraceToken .WithLeadingTrivia(TriviaList(NewLine()))); LambdaExpressionSyntax newLambda = lambda; switch (lambda.Kind()) { case SyntaxKind.SimpleLambdaExpression: { newLambda = ((SimpleLambdaExpressionSyntax)lambda).WithBody(block); break; } case SyntaxKind.ParenthesizedLambdaExpression: { newLambda = ((ParenthesizedLambdaExpressionSyntax)lambda).WithBody(block); break; } } newLambda = newLambda.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(lambda, newLambda, cancellationToken).ConfigureAwait(false)); }
private static ImmutableArray <ParameterSyntax> GetParameters(LambdaExpressionSyntax lambdaExpression) { switch (lambdaExpression.Kind()) { case SyntaxKind.SimpleLambdaExpression: return(ImmutableArray.Create(((SimpleLambdaExpressionSyntax)lambdaExpression).Parameter)); case SyntaxKind.ParenthesizedLambdaExpression: return(((ParenthesizedLambdaExpressionSyntax)lambdaExpression).ParameterList.Parameters.ToImmutableArray()); default: Debug.Fail("Unreachable"); return(ImmutableArray <ParameterSyntax> .Empty); } }
public static Task <Document> RefactorAsync( Document document, LambdaExpressionSyntax lambda, CancellationToken cancellationToken = default(CancellationToken)) { var block = (BlockSyntax)lambda.Body; StatementSyntax statement = block.Statements[0]; ExpressionSyntax expression = GetNewExpression(statement).WithoutTrivia(); LambdaExpressionSyntax newLambda = GetNewLambda() .WithTriviaFrom(lambda) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(lambda, newLambda, cancellationToken)); LambdaExpressionSyntax GetNewLambda() { switch (lambda.Kind()) { case SyntaxKind.SimpleLambdaExpression: { return(((SimpleLambdaExpressionSyntax)lambda) .WithArrowToken(lambda.ArrowToken.WithTrailingTrivia(TriviaList(Space))) .WithBody(expression)); } case SyntaxKind.ParenthesizedLambdaExpression: { return(((ParenthesizedLambdaExpressionSyntax)lambda) .WithArrowToken(lambda.ArrowToken.WithTrailingTrivia(TriviaList(Space))) .WithBody(expression)); } default: { throw new InvalidOperationException(); } } } }