private static SyntaxTriviaList GetLeadingTrivia(BlockSyntax block, StatementSyntax statement)
{
switch (statement.Kind())
{
case SyntaxKind.ReturnStatement:
{
var returnStatement = (ReturnStatementSyntax)statement;
return(block.GetLeadingTrivia()
.AddRange(block.OpenBraceToken.TrailingTrivia)
.AddRange(returnStatement.ReturnKeyword.GetLeadingAndTrailingTrivia())
.AddRange(returnStatement.Expression.GetLeadingTrivia())
.TrimLeadingWhitespace());
}
case SyntaxKind.ExpressionStatement:
{
var expressionStatement = (ExpressionStatementSyntax)statement;
return(block.GetLeadingTrivia()
.AddRange(block.OpenBraceToken.TrailingTrivia)
.AddRange(expressionStatement.GetLeadingTrivia())
.AddRange(expressionStatement.Expression.GetLeadingTrivia())
.TrimLeadingWhitespace());
}
}
return(SyntaxTriviaList.Empty);
}
public override SyntaxNode VisitBlock(BlockSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitBlock(node));
}
protected bool ExpandWithStatements(SyntaxList <StatementSyntax> statements, out SyntaxList <StatementSyntax> newStatements)
{
//check if list contains "with" syntax
if (!statements.Where(p => (p.Kind == SyntaxKind.WithStatement)).Any())
{
newStatements = statements;
return(false);
}
//collect new list of statements
List <StatementSyntax> newStatementsList = new List <StatementSyntax>();
foreach (StatementSyntax statementSyntax in statements)
{
if (statementSyntax.Kind == SyntaxKind.WithStatement)
{
SyntaxNode newWithNode = this.Visit(statementSyntax);
if (newWithNode.Kind == SyntaxKind.Block)
{
BlockSyntax newWithBlock = (BlockSyntax)newWithNode;
if (newWithBlock.Statements.Count > 0)
{
int newStartIdx = newStatementsList.Count;
newStatementsList.AddRange(newWithBlock.Statements);
//copy leading and trailing trivia from block to the first and last block statements
//as they might contain important information
newStatementsList[newStartIdx] = newStatementsList[newStartIdx]
.WithLeadingTrivia(
newWithBlock.GetLeadingTrivia()
.AddRange(newStatementsList[newStartIdx].GetLeadingTrivia())
.NormalizeSyntaxTriviaList());
int newEndIdx = newStatementsList.Count - 1;
newStatementsList[newEndIdx] = newStatementsList[newEndIdx]
.WithTrailingTrivia(
newStatementsList[newEndIdx].GetTrailingTrivia()
.AddRange(newWithBlock.EndKeywordToken.LeadingTrivia)
.AddRange(newWithBlock.GetTrailingTrivia())
.NormalizeSyntaxTriviaList());
}
}
else
{
newStatementsList.Add((StatementSyntax)newWithNode);
}
}
else
{
newStatementsList.Add(statementSyntax);
}
}
newStatements = SyntaxFactory.List <StatementSyntax>(newStatementsList);
return(true);
}
public static BlockSyntax RemoveUnsafeContext(UnsafeStatementSyntax unsafeStatement)
{
SyntaxToken keyword = unsafeStatement.UnsafeKeyword;
BlockSyntax block = unsafeStatement.Block;
SyntaxTriviaList leadingTrivia = keyword.LeadingTrivia
.AddRange(keyword.TrailingTrivia.EmptyIfWhitespace())
.AddRange(block.GetLeadingTrivia().EmptyIfWhitespace());
return(block.WithLeadingTrivia(leadingTrivia));
}
public static Task <Document> RefactorAsync(
Document document,
BlockSyntax block,
CancellationToken cancellationToken)
{
StatementSyntax statement = block
.Statements[0]
.TrimTrivia()
.PrependToLeadingTrivia(block.GetLeadingTrivia())
.AppendToTrailingTrivia(block.GetTrailingTrivia())
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(block, statement, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
UnsafeStatementSyntax unsafeStatement,
CancellationToken cancellationToken)
{
SyntaxToken keyword = unsafeStatement.UnsafeKeyword;
BlockSyntax block = unsafeStatement.Block;
IEnumerable <SyntaxTrivia> leadingTrivia = keyword.LeadingTrivia
.AddRange(keyword.TrailingTrivia.EmptyIfWhitespace())
.AddRange(block.GetLeadingTrivia().EmptyIfWhitespace());
BlockSyntax newBlock = block.WithLeadingTrivia(leadingTrivia);
return(document.ReplaceNodeAsync(unsafeStatement, newBlock, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
UnsafeStatementSyntax unsafeStatement,
SyntaxNode containingNode,
CancellationToken cancellationToken)
{
SyntaxToken keyword = unsafeStatement.UnsafeKeyword;
BlockSyntax block = unsafeStatement.Block;
SyntaxList <StatementSyntax> statements = block.Statements;
SyntaxNode newNode = null;
int count = statements.Count;
if (count == 0)
{
newNode = containingNode.RemoveNode(unsafeStatement);
}
else
{
StatementSyntax first = statements.First();
StatementSyntax last = statements.Last();
SyntaxTriviaList leadingTrivia = keyword.LeadingTrivia
.AddRange(keyword.TrailingTrivia.EmptyIfWhitespace())
.AddRange(block.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(block.OpenBraceToken.TrailingTrivia.EmptyIfWhitespace())
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace());
SyntaxTriviaList trailingTrivia = last.GetTrailingTrivia().EmptyIfWhitespace()
.AddRange(block.CloseBraceToken.LeadingTrivia.EmptyIfWhitespace())
.AddRange(block.GetTrailingTrivia());
statements = statements
.ReplaceAt(0, first.WithLeadingTrivia(leadingTrivia))
.ReplaceAt(count - 1, last.WithTrailingTrivia(trailingTrivia));
newNode = containingNode.ReplaceNode(unsafeStatement, statements.Select(f => f.WithFormatterAnnotation()));
}
newNode = newNode.InsertModifier(SyntaxKind.UnsafeKeyword);
return(document.ReplaceNodeAsync(containingNode, newNode, cancellationToken));
}
public static BlockSyntax Trivia(this BlockSyntax node, BlockSyntax that)
{
return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia());
}
