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();
}
}
}
}
