private static SyntaxNode SimplifyParenthesizedLambdaExpression(
SyntaxNode node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (node != null && node is ParenthesizedLambdaExpressionSyntax)
{
var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)node;
if (parenthesizedLambda.ParameterList != null &&
parenthesizedLambda.ParameterList.Parameters.Count == 1)
{
var parameter = parenthesizedLambda.ParameterList.Parameters.First();
if (CanRemoveTypeFromParameter(parameter, semanticModel, cancellationToken))
{
var newParameterSyntax = parameter.WithType(null);
var newSimpleLambda = SyntaxFactory.SimpleLambdaExpression(
parenthesizedLambda.AsyncKeyword,
newParameterSyntax.WithTrailingTrivia(parenthesizedLambda.ParameterList.GetTrailingTrivia()),
parenthesizedLambda.ArrowToken,
parenthesizedLambda.Body);
return(SimplificationHelpers.CopyAnnotations(parenthesizedLambda, newSimpleLambda).WithoutAnnotations(Simplifier.Annotation));
}
}
}
return(node);
}
private static ExpressionSyntax SimplifyCast(CastExpressionSyntax node, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken)
{
if (!node.IsUnnecessaryCast(semanticModel, cancellationToken))
{
return(node);
}
var leadingTrivia = node.OpenParenToken.LeadingTrivia
.Concat(node.OpenParenToken.TrailingTrivia)
.Concat(node.Type.GetLeadingTrivia())
.Concat(node.Type.GetTrailingTrivia())
.Concat(node.CloseParenToken.LeadingTrivia)
.Concat(node.CloseParenToken.TrailingTrivia)
.Concat(node.Expression.GetLeadingTrivia())
.Where(t => !t.IsElastic());
var trailingTrivia = node.GetTrailingTrivia().Where(t => !t.IsElastic());
var resultNode = node.Expression
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(trailingTrivia);
resultNode = SimplificationHelpers.CopyAnnotations(from: node, to: resultNode);
return(resultNode);
}
public override SyntaxNode VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
{
var newNode = base.VisitSimpleLambdaExpression(node);
if (newNode is SimpleLambdaExpressionSyntax && _expandParameter)
{
var newSimpleLambda = (SimpleLambdaExpressionSyntax)newNode;
var parameterSymbol = _semanticModel.GetDeclaredSymbol(node.Parameter);
if (parameterSymbol != null && parameterSymbol.Kind == SymbolKind.Parameter)
{
if (parameterSymbol.Type != null)
{
var typeSyntax = parameterSymbol.Type.GenerateTypeSyntax().WithTrailingTrivia(s_oneWhitespaceSeparator);
var newSimpleLambdaParameter = newSimpleLambda.Parameter.WithType(typeSyntax).WithoutTrailingTrivia();
var parenthesizedLambda = SyntaxFactory.ParenthesizedLambdaExpression(
newSimpleLambda.AsyncKeyword,
SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(newSimpleLambdaParameter))
.WithTrailingTrivia(newSimpleLambda.Parameter.GetTrailingTrivia())
.WithLeadingTrivia(newSimpleLambda.Parameter.GetLeadingTrivia()),
newSimpleLambda.ArrowToken,
newSimpleLambda.Body).WithAdditionalAnnotations(Simplifier.Annotation);
return(SimplificationHelpers.CopyAnnotations(newNode, parenthesizedLambda));
}
}
}
return(newNode);
}
private static SyntaxNode SimplifyParameter(
SyntaxNode node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (CanRemoveTypeFromParameter(node, semanticModel, cancellationToken))
{
var newParameterSyntax = ((ParameterSyntax)node).WithType(null);
newParameterSyntax = SimplificationHelpers.CopyAnnotations(node, newParameterSyntax).WithoutAnnotations(Simplifier.Annotation);
return(newParameterSyntax);
}
return(node);
}
private static SyntaxNode SimplifyParentheses(
ParenthesizedPatternSyntax node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (node.CanRemoveParentheses(semanticModel))
{
var resultNode = CSharpSyntaxFacts.Instance.Unparenthesize(node);
return(SimplificationHelpers.CopyAnnotations(from: node, to: resultNode));
}
// We don't know how to simplify this.
return(node);
}
private static SyntaxNode SimplifyParentheses(
ParenthesizedExpressionSyntax node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (node.CanRemoveParentheses(semanticModel))
{
// TODO(DustinCa): We should not be skipping elastic trivia below.
// However, the formatter seems to mess up trailing trivia in some
// cases if elastic trivia is there -- and it's not clear why.
// Specifically remove the elastic trivia formatting rule doesn't
// have any effect.
var resultNode = CSharpSyntaxFactsService.Instance.Unparenthesize(node);
return(SimplificationHelpers.CopyAnnotations(from: node, to: resultNode));
}
// We don't know how to simplify this.
return(node);
}
public static ExpressionSyntax Uncast(this CastExpressionSyntax node)
{
var leadingTrivia = node.OpenParenToken.LeadingTrivia
.Concat(node.OpenParenToken.TrailingTrivia)
.Concat(node.Type.GetLeadingTrivia())
.Concat(node.Type.GetTrailingTrivia())
.Concat(node.CloseParenToken.LeadingTrivia)
.Concat(node.CloseParenToken.TrailingTrivia)
.Concat(node.Expression.GetLeadingTrivia())
.Where(t => !t.IsElastic());
var trailingTrivia = node.GetTrailingTrivia().Where(t => !t.IsElastic());
var resultNode = node.Expression
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(trailingTrivia)
.WithAdditionalAnnotations(Simplifier.Annotation);
resultNode = SimplificationHelpers.CopyAnnotations(from: node, to: resultNode);
return resultNode;
}
private static SyntaxNode SimplifyParentheses(
ParenthesizedExpressionSyntax node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (node.CanRemoveParentheses(semanticModel))
{
// TODO(DustinCa): We should not be skipping elastic trivia below.
// However, the formatter seems to mess up trailing trivia in some
// cases if elastic trivia is there -- and it's not clear why.
// Specifically remove the elastic trivia formatting rule doesn't
// have any effect.
var leadingTrivia = node.OpenParenToken.LeadingTrivia
.Concat(node.OpenParenToken.TrailingTrivia)
.Where(t => !t.IsElastic())
.Concat(node.Expression.GetLeadingTrivia());
var trailingTrivia = node.Expression.GetTrailingTrivia()
.Concat(node.CloseParenToken.LeadingTrivia)
.Where(t => !t.IsElastic())
.Concat(node.CloseParenToken.TrailingTrivia);
var resultNode = node.Expression
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(trailingTrivia);
resultNode = SimplificationHelpers.CopyAnnotations(from: node, to: resultNode);
return(resultNode);
}
// We don't know how to simplify this.
return(node);
}
