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