private static ImmutableArray <string> GetIgnoredPropertyNamesFromCommentedAssignments(
ObjectCreationExpressionSyntax objectCreation)
{
// Case 1: Commented member assignments before one or more actual member assignments
// return new Foo {
// // Prop1 = null,
// // Prop2 = null,
// Prop3 = 1
// };
SyntaxTriviaList memberAssignmentsLeadingTrivia =
new SyntaxTriviaList().AddRange(objectCreation.Initializer.Expressions
.OfType <AssignmentExpressionSyntax>()
.SelectMany(e => e.Left.GetLeadingTrivia()));
// Case 2: Commented member assignments before closing brace
// return new Foo {
// Prop3 = 1
// // Prop1 = null,
// // Prop2 = null,
// };
SyntaxTriviaList closingBraceLeadingTrivia = objectCreation.Initializer.CloseBraceToken.LeadingTrivia;
return
(memberAssignmentsLeadingTrivia
.Concat(closingBraceLeadingTrivia)
.Where(trivia => trivia.IsKind(SyntaxKind.SingleLineCommentTrivia))
.Select(trivia => AssignAll_Analyzer.CommentedMemberAssignmentRegex
.Match(trivia.ToString()))
.Where(match => match.Success)
.Select(match => match.Groups[1].Value)
.ToImmutableArray());
}
private static SyntaxTriviaList GetTrivia(SyntaxNode node, SyntaxTokenList modifiers, SyntaxToken modifier, int i)
{
SyntaxTriviaList leading = modifier.LeadingTrivia;
SyntaxTriviaList trailing = modifier.TrailingTrivia;
if (leading.Any())
{
if (trailing.All(f => f.IsWhitespaceTrivia()))
{
return(leading);
}
else
{
return(leading.Concat(trailing).ToSyntaxTriviaList());
}
}
else
{
SyntaxToken previousToken = (i == 0)
? FindPreviousToken(node, modifier)
: modifiers[i - 1];
if (!previousToken.IsKind(SyntaxKind.None) &&
previousToken.TrailingTrivia.Any() &&
trailing.All(f => f.IsWhitespaceTrivia()))
{
return(default(SyntaxTriviaList));
}
else
{
return(trailing);
}
}
}
public static Task <Document> RemoveRedundantAssignmentAfterLocalDeclarationAsync(
Document document,
VariableDeclaratorSyntax declarator,
CancellationToken cancellationToken = default)
{
var declaration = (VariableDeclarationSyntax)declarator.Parent;
var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent;
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(localDeclaration);
StatementSyntax nextStatement = statements[index + 1];
var expressionStatement = (ExpressionStatementSyntax)nextStatement;
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
ExpressionSyntax right = assignment.Right;
EqualsValueClauseSyntax initializer = declarator.Initializer;
ExpressionSyntax value = initializer?.Value;
VariableDeclaratorSyntax newDeclarator = (value != null)
? declarator.ReplaceNode(value, right)
: declarator.WithInitializer(EqualsValueClause(right));
LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator);
SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia();
if (!trailingTrivia.IsEmptyOrWhitespace())
{
newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia()));
}
else
{
newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia());
}
SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia();
if (!leadingTrivia.IsEmptyOrWhitespace())
{
newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia));
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(localDeclaration, newLocalDeclaration)
.RemoveAt(index + 1);
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
VariableDeclaratorSyntax declarator,
CancellationToken cancellationToken)
{
var declaration = (VariableDeclarationSyntax)declarator.Parent;
var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent;
StatementContainer container = StatementContainer.Create(localDeclaration);
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(localDeclaration);
StatementSyntax nextStatement = statements[index + 1];
var expressionStatement = (ExpressionStatementSyntax)nextStatement;
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
ExpressionSyntax right = assignment.Right;
EqualsValueClauseSyntax initializer = declarator.Initializer;
ExpressionSyntax value = initializer?.Value;
VariableDeclaratorSyntax newDeclarator = (value != null)
? declarator.ReplaceNode(value, right)
: declarator.WithInitializer(EqualsValueClause(right));
LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator);
SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia();
if (trailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia()));
}
else
{
newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia());
}
SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia();
if (leadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia));
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(localDeclaration, newLocalDeclaration)
.RemoveAt(index + 1);
return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken));
}
public static SyntaxToken WithPrependedLeadingTrivia(
this SyntaxToken token,
SyntaxTriviaList trivia)
{
if (trivia.Count == 0)
{
return(token);
}
return(token.WithLeadingTrivia(trivia.Concat(token.LeadingTrivia)));
}
public static T WithPrependedLeadingTrivia <T>(
this T node,
SyntaxTriviaList trivia) where T : SyntaxNode
{
if (trivia.Count == 0)
{
return(node);
}
return(node.WithLeadingTrivia(trivia.Concat(node.GetLeadingTrivia())));
}
protected static T AppendTriviaAtPosition <T>(T node, int position, SyntaxTriviaList trivia)
where T : SyntaxNode
{
if (trivia.Any())
{
var tokenToInsertTrivia = node.FindToken(position);
var tokenWithInsertedTrivia = tokenToInsertTrivia.WithLeadingTrivia(trivia.Concat(tokenToInsertTrivia.LeadingTrivia));
return(node.ReplaceToken(tokenToInsertTrivia, tokenWithInsertedTrivia));
}
return(node);
}
internal T WithPrependedLeadingTrivia <T>(T node, SyntaxTriviaList trivia) where T : SyntaxNode
{
if (trivia.Count == 0)
{
return(node);
}
if (trivia.Last().IsKind(VB.SyntaxKind.CommentTrivia))
{
trivia = trivia.Add(global::VisualBasicSyntaxFactory.VBEOLTrivia);
}
return(node.WithLeadingTrivia(trivia.Concat(node.GetLeadingTrivia())));
}
public static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
StatementContainer container;
if (StatementContainer.TryCreate(localDeclaration, out container))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(localDeclaration);
ExpressionSyntax value = localDeclaration
.Declaration
.Variables
.First()
.Initializer
.Value;
StatementSyntax nextStatement = statements[index + 1];
StatementSyntax newStatement = GetStatementWithReplacedValue(nextStatement, value);
SyntaxTriviaList leadingTrivia = localDeclaration.GetLeadingTrivia();
IEnumerable <SyntaxTrivia> trivia = container
.Node
.DescendantTrivia(TextSpan.FromBounds(localDeclaration.SpanStart, nextStatement.Span.Start));
if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia.Concat(trivia));
}
else
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia);
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(nextStatement, newStatement)
.RemoveAt(index);
return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false));
}
Debug.Assert(false, "");
return(document);
}
private static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration);
int index = statementsInfo.Statements.IndexOf(localDeclaration);
StatementSyntax nextStatement = statementsInfo.Statements[index + 1];
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax value = GetExpressionToInline(localDeclaration, semanticModel, cancellationToken);
StatementSyntax newStatement = GetStatementWithInlinedExpression(nextStatement, value);
SyntaxTriviaList leadingTrivia = localDeclaration.GetLeadingTrivia();
IEnumerable <SyntaxTrivia> trivia = statementsInfo
.Parent
.DescendantTrivia(TextSpan.FromBounds(localDeclaration.SpanStart, nextStatement.SpanStart));
if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia.Concat(trivia));
}
else
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia);
}
SyntaxList <StatementSyntax> newStatements = statementsInfo.Statements
.Replace(nextStatement, newStatement)
.RemoveAt(index);
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
StatementContainer container = StatementContainer.Create(localDeclaration);
int index = container.Statements.IndexOf(localDeclaration);
StatementSyntax nextStatement = container.Statements[index + 1];
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax value = GetExpressionToInline(localDeclaration, semanticModel, cancellationToken);
StatementSyntax newStatement = GetStatementWithInlinedExpression(nextStatement, value);
SyntaxTriviaList leadingTrivia = localDeclaration.GetLeadingTrivia();
IEnumerable <SyntaxTrivia> trivia = container
.Node
.DescendantTrivia(TextSpan.FromBounds(localDeclaration.SpanStart, nextStatement.Span.Start));
if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia.Concat(trivia));
}
else
{
newStatement = newStatement.WithLeadingTrivia(leadingTrivia);
}
SyntaxList <StatementSyntax> newStatements = container.Statements
.Replace(nextStatement, newStatement)
.RemoveAt(index);
return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false));
}
private static SyntaxTriviaList BuildTriviaList(IEnumerable <SyntaxTrivia> newTrivia, SyntaxTriviaList oldTrivia)
{
var fullTrivia = oldTrivia.Concat(newTrivia);
return(SyntaxFactory.TriviaList(fullTrivia));
}
public static SyntaxToken WithPrependedLeadingTrivia(
this SyntaxToken token,
SyntaxTriviaList trivia)
{
if (trivia.Count == 0)
{
return token;
}
return token.WithLeadingTrivia(trivia.Concat(token.LeadingTrivia));
}
