public static Boolean IsOnLineByItself(ExpressionStatementSyntax node)
{
Boolean result = false;
// Seems like Trivia is Trivia No notion of with our without :)
string existingLeadingTrivia = node.GetLeadingTrivia().ToString();
//string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString();
string existingTrailingTrivia = node.GetTrailingTrivia().ToString();
//string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString();
if (String.IsNullOrWhiteSpace(existingLeadingTrivia) && String.IsNullOrWhiteSpace(existingTrailingTrivia))
{
result = true;
}
else
{
var triviaList = node.GetLeadingTrivia().ToSyntaxTriviaList();
Boolean leadingTriviaResult = false;
foreach (SyntaxTrivia syntaxTrivia in node.GetLeadingTrivia().ToSyntaxTriviaList())
{
var triviaKind = syntaxTrivia.Kind();
if (triviaKind == SyntaxKind.EndOfLineTrivia ||
triviaKind == SyntaxKind.WhitespaceTrivia ||
triviaKind == SyntaxKind.MultiLineCommentTrivia ||
triviaKind == SyntaxKind.SingleLineCommentTrivia)
{
leadingTriviaResult = true;
}
}
Boolean trailingTriviaResult = false;
foreach (SyntaxTrivia syntaxTrivia in node.GetTrailingTrivia().ToSyntaxTriviaList())
{
var triviaKind = syntaxTrivia.Kind();
if (triviaKind == SyntaxKind.EndOfLineTrivia ||
triviaKind == SyntaxKind.WhitespaceTrivia ||
triviaKind == SyntaxKind.MultiLineCommentTrivia ||
triviaKind == SyntaxKind.SingleLineCommentTrivia)
{
trailingTriviaResult = true;
}
}
result = leadingTriviaResult & trailingTriviaResult;
}
return(result);
}
private async Task <Solution> AddIsEnabledGuardAsync(Document document, ExpressionStatementSyntax expression,
CancellationToken cancellationToken)
{
var memberAccessExpression = expression.DescendantNodes().OfType <MemberAccessExpressionSyntax>().First();
if (memberAccessExpression.Expression is IdentifierNameSyntax identifierNameSyntax)
{
if (expression.Expression is InvocationExpressionSyntax invocation)
{
var leadingTrivia = expression.GetLeadingTrivia();
var arg = invocation.ArgumentList.Arguments.First();
var source = identifierNameSyntax.Identifier.Text;
var isEnabled =
SyntaxFactory.ParseExpression($"{source}.IsEnabled()") as InvocationExpressionSyntax;
isEnabled = isEnabled.ReplaceNode(isEnabled.ArgumentList, isEnabled.ArgumentList.AddArguments(arg));
SyntaxFactory.Token(SyntaxKind.IfKeyword);
var ifStatement = SyntaxFactory.IfStatement(
SyntaxFactory.Token(SyntaxKind.IfKeyword),
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
isEnabled,
SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTrailingTrivia(NewLine),
Indent(expression), null).WithLeadingTrivia(leadingTrivia);
// Produce a new solution that has all references to that type renamed, including the declaration.
var originalSolution = document.Project.Solution;
var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken);
syntaxRoot = syntaxRoot.ReplaceNode(expression, ifStatement);
var newSolution = originalSolution.WithDocumentSyntaxRoot(document.Id, syntaxRoot);
return(newSolution);
}
}
return(document.Project.Solution);
}
public virtual Task <Document> InlineAsync(
ExpressionStatementSyntax expressionStatement,
SyntaxList <StatementSyntax> statements,
CancellationToken cancellationToken = default(CancellationToken))
{
int count = statements.Count;
StatementSyntax[] newStatements = RewriteStatements(statements);
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement);
if (statementsInfo.Success)
{
StatementListInfo newInfo = statementsInfo.WithStatements(statementsInfo.Statements.ReplaceRange(expressionStatement, newStatements));
return(Document.ReplaceNodeAsync(statementsInfo.Parent, newInfo.Parent, cancellationToken));
}
else
{
return(Document.ReplaceNodeAsync(expressionStatement, Block(newStatements), cancellationToken));
}
}
private static async Task <Document> InlineMethodAsync(
Document document,
ExpressionStatementSyntax expressionStatement,
StatementSyntax[] statements,
ParameterInfo[] parameterInfos,
CancellationToken cancellationToken = default(CancellationToken))
{
statements = await ReplaceParameterExpressionWithArgumentExpressionAsync(
parameterInfos,
statements,
document.Project.Solution,
cancellationToken).ConfigureAwait(false);
statements[0] = statements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
statements[statements.Length - 1] = statements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
if (expressionStatement.IsParentKind(SyntaxKind.Block))
{
var block = (BlockSyntax)expressionStatement.Parent;
BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, statements));
return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false));
}
else
{
return(await document.ReplaceNodeAsync(expressionStatement, Block(statements), cancellationToken).ConfigureAwait(false));
}
}
private async Task <Document> MakeBlockAsync(Document document, ExpressionStatementSyntax trueStatement,
CancellationToken cancellationToken)
{
// Create the important trivia that we need.
var statementLeadingTrivia = trueStatement.GetLeadingTrivia();
var statementLeadingWhiteSpace = trueStatement.Parent.GetLeadingTrivia()
.Where(t => t.Kind() == SyntaxKind.WhitespaceTrivia).Single();
var endOfLineTrivia = SyntaxFactory.EndOfLine("\r\n");
var blockLeadingTrivia = statementLeadingTrivia.Insert(0, endOfLineTrivia);
// Create the statements that go in the block:
var statements = new SyntaxList <StatementSyntax>();
statements = statements.Add(trueStatement.WithLeadingTrivia(blockLeadingTrivia));
// Create the brace tokens (with whitespace trivia) and the the block:
var openingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(statementLeadingWhiteSpace);
var closingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithLeadingTrivia(statementLeadingWhiteSpace);
var block = SyntaxFactory.Block(openingTokenWithTrivia, statements, closingTokenWithTrivia)
.WithTrailingTrivia(endOfLineTrivia);
// Replace the old statement with the block:
var root = await document.GetSyntaxRootAsync();
var newRoot = root.ReplaceNode((SyntaxNode)trueStatement, block);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitExpressionStatement(node));
}
public ExpressionStatementSyntax TryReplaceAssignmentExpressionWithMethodCall(ExpressionStatementSyntax node, INamedTypeSymbol typeSymbol = null)
{
// There are 2 cases to consider
// Either we stub a method/property by setting a property; set value being the stub lambda
// Or by invoking a method having a single argument; method argument being the stub lambda
StubbedCall msStub = null;
var assignment = node.ChildNodes().OfType <AssignmentExpressionSyntax>().FirstOrDefault();
if (assignment != null)
{
var member = assignment.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax;
if (member == null)
{
return(null);
}
var resultExpression = assignment.Right;
msStub = StubMsTestMethodOrPropertyCall(assignment, member, resultExpression, typeSymbol);
}
else
{
var invocation = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault();
if (invocation == null)
{
return(null);
}
var member = invocation.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax;
if (member == null)
{
return(null);
}
var argument = invocation.ArgumentList.ChildNodes().FirstOrDefault() as ArgumentSyntax;
if (argument == null)
{
return(null);
}
msStub = StubMsTestMethodOrPropertyCall(invocation, member, argument.Expression, typeSymbol);
}
if (msStub != null)
{
var moqStub = MockMethodOrPropertyCall(msStub);
var stubDefinition = SyntaxFactory.ExpressionStatement(moqStub.NewNode)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
return(stubDefinition);
}
return(null);
}
private static async Task <Solution> InlineAndRemoveMethodAsync(
Document document,
ExpressionStatementSyntax expressionStatement,
MethodDeclarationSyntax methodDeclaration,
StatementSyntax[] statements,
ParameterInfo[] parameterInfos,
CancellationToken cancellationToken = default(CancellationToken))
{
if (expressionStatement.SyntaxTree.Equals(methodDeclaration.SyntaxTree))
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
Solution solution = document.Project.Solution;
StatementSyntax[] newStatements = await ReplaceParameterExpressionWithArgumentExpressionAsync(
parameterInfos,
statements,
solution,
cancellationToken).ConfigureAwait(false);
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[statements.Length - 1] = newStatements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
if (expressionStatement.Parent.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)expressionStatement.Parent;
BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, newStatements));
editor.ReplaceNode(block, newBlock);
}
else
{
editor.ReplaceNode(expressionStatement, Block(newStatements));
}
editor.RemoveNode(methodDeclaration);
document = editor.GetChangedDocument();
return(document.Project.Solution);
}
else
{
Solution solution = document.Project.Solution;
document = await InlineMethodAsync(document, expressionStatement, statements, parameterInfos, cancellationToken).ConfigureAwait(false);
DocumentId documentId = solution.GetDocumentId(methodDeclaration.SyntaxTree);
solution = document.Project.Solution;
return(await RemoveMethodAsync(solution.GetDocument(documentId), methodDeclaration, cancellationToken).ConfigureAwait(false));
}
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (node.Expression is ParenthesizedExpressionSyntax syntax)
{
var expression = syntax
.Expression
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia());
return(node.WithExpression(expression));
}
return(base.VisitExpressionStatement(node));
}
private async Task <Document> RemoveCall(Document document, ExpressionStatementSyntax call, CancellationToken cancellationToken)
{
var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
var containsLeadingComment = call.GetLeadingTrivia()
.Any(t => t.IsKind(SyntaxKind.MultiLineCommentTrivia) || t.IsKind(SyntaxKind.SingleLineCommentTrivia));
var removeOptions = containsLeadingComment
? SyntaxRemoveOptions.KeepLeadingTrivia | SyntaxRemoveOptions.AddElasticMarker
: SyntaxRemoveOptions.KeepNoTrivia;
editor.RemoveNode(call, removeOptions);
return(editor.GetChangedDocument());
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()?
.ChildTokens()?.FirstOrDefault().Text;
if (invocationName == null)
{
invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()?
.ChildTokens()?.FirstOrDefault().Text;
}
if (invocationName != null && invocationName.Equals("YIELD", StringComparison.OrdinalIgnoreCase))
{
var genericName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()?
.ChildNodes().OfType <TypeArgumentListSyntax>().FirstOrDefault()?
.ChildNodes().OfType <PredefinedTypeSyntax>().FirstOrDefault()?.Keyword.Text;
var varName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <ArgumentListSyntax>().FirstOrDefault()?
.ChildNodes().OfType <ArgumentSyntax>().FirstOrDefault()?
.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()?.GetText().ToString();
String type = "var";
if (genericName != null)
{
type = genericName;
}
var leadingTrivia = node.GetLeadingTrivia();
var forEachExp = SyntaxFactory.ForEachStatement(
SyntaxFactory.Token(SyntaxKind.ForEachKeyword),
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
SyntaxFactory.IdentifierName(type),
SyntaxFactory.Identifier("item"),
SyntaxFactory.Token(SyntaxKind.InKeyword),
SyntaxFactory.IdentifierName(varName),
SyntaxFactory.Token(SyntaxKind.CloseParenToken)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine))
.WithTrailingTrivia(leadingTrivia),
SyntaxFactory.Block(
SyntaxFactory.YieldStatement(
SyntaxKind.YieldReturnStatement,
SyntaxFactory.IdentifierName("item").WithLeadingTrivia(leadingTrivia)
)
)).NormalizeWhitespace().WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine));
return(forEachExp);
}
return(base.VisitExpressionStatement(node));
}
private static ExpressionStatementSyntax CommentExpressionStatement(ExpressionStatementSyntax expressionStatement)
{
string[] triviaList = expressionStatement.GetLeadingTrivia().ToFullString().Split(Environment.NewLine.ToCharArray());
triviaList[triviaList.Length - 1] = "//" + triviaList[triviaList.Length - 1];
string resultTrivia = "";
for (int i = 0; i < triviaList.Length - 1; i++)
{
resultTrivia += triviaList[i] + Environment.NewLine;
}
resultTrivia += triviaList[triviaList.Length - 1];
return(expressionStatement.WithLeadingTrivia(SyntaxFactory.ParseLeadingTrivia(resultTrivia)));
}
internal static void MoveOnPropertyChangedInside(this DocumentEditor editor, IfStatementSyntax ifTrySet, ExpressionStatementSyntax onPropertyChanged)
{
editor.RemoveNode(onPropertyChanged);
editor.AddOnPropertyChanged(ifTrySet, OnPropertyChanged());
ExpressionStatementSyntax OnPropertyChanged()
{
if (onPropertyChanged.HasLeadingTrivia &&
onPropertyChanged.GetLeadingTrivia() is { } leadingTrivia&&
leadingTrivia.TryFirst(out var first) &&
first.IsKind(SyntaxKind.EndOfLineTrivia))
{
onPropertyChanged = onPropertyChanged.WithLeadingTrivia(leadingTrivia.Remove(first));
}
return(onPropertyChanged.WithAdditionalAnnotations(Formatter.Annotation));
}
}
public virtual async Task <Solution> InlineAndRemoveAsync(
ExpressionStatementSyntax expressionStatement,
SyntaxList <StatementSyntax> statements,
CancellationToken cancellationToken = default(CancellationToken))
{
if (expressionStatement.SyntaxTree == Declaration.SyntaxTree)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(Document, cancellationToken).ConfigureAwait(false);
StatementSyntax[] newStatements = RewriteStatements(statements);
int count = statements.Count;
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement);
if (statementsInfo.Success)
{
StatementListInfo newStatementsInfo = statementsInfo.WithStatements(statementsInfo.Statements.ReplaceRange(expressionStatement, newStatements));
editor.ReplaceNode(statementsInfo.Parent, newStatementsInfo.Parent);
}
else
{
editor.ReplaceNode(expressionStatement, Block(newStatements));
}
editor.RemoveNode(Declaration);
return(editor.GetChangedDocument().Solution());
}
else
{
Document newDocument = await InlineAsync(expressionStatement, statements, cancellationToken).ConfigureAwait(false);
DocumentId documentId = Document.Solution().GetDocumentId(Declaration.SyntaxTree);
newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(Declaration, cancellationToken).ConfigureAwait(false);
return(newDocument.Solution());
}
}
public async Task <Solution> InlineAndRemoveMethodAsync(
ExpressionStatementSyntax expressionStatement,
SyntaxList <StatementSyntax> statements)
{
if (expressionStatement.SyntaxTree == MethodDeclaration.SyntaxTree)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(Document, CancellationToken).ConfigureAwait(false);
StatementSyntax[] newStatements = RewriteStatements(statements);
int count = statements.Count;
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
StatementContainer container;
if (StatementContainer.TryCreate(expressionStatement, out container))
{
SyntaxNode newNode = container.NodeWithStatements(container.Statements.ReplaceRange(expressionStatement, newStatements));
editor.ReplaceNode(container.Node, newNode);
}
else
{
editor.ReplaceNode(expressionStatement, Block(newStatements));
}
editor.RemoveNode(MethodDeclaration);
return(editor.GetChangedDocument().Solution());
}
else
{
Document newDocument = await InlineMethodAsync(expressionStatement, statements).ConfigureAwait(false);
DocumentId documentId = Document.Solution().GetDocumentId(MethodDeclaration.SyntaxTree);
newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(MethodDeclaration, CancellationToken).ConfigureAwait(false);
return(newDocument.Solution());
}
}
public Task <Document> InlineMethodAsync(
ExpressionStatementSyntax expressionStatement,
SyntaxList <StatementSyntax> statements)
{
int count = statements.Count;
StatementSyntax[] newStatements = RewriteStatements(statements);
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
if (StatementContainer.TryCreate(expressionStatement, out StatementContainer container))
{
SyntaxNode newNode = container.NodeWithStatements(container.Statements.ReplaceRange(expressionStatement, newStatements));
return(Document.ReplaceNodeAsync(container.Node, newNode, CancellationToken));
}
else
{
return(Document.ReplaceNodeAsync(expressionStatement, Block(newStatements), CancellationToken));
}
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
Location loc = node.GetLocation();
bool suppress = false;
bool wroteHeader = false;
foreach (Diagnostic error in errors)
{
if ((loc.SourceSpan.Start <= error.Location.SourceSpan.Start) &&
(loc.SourceSpan.End >= error.Location.SourceSpan.End))
{
#pragma warning disable CS0162 // unreachable
if (trace)
{
if (!wroteHeader)
{
Console.WriteLine("REMOVING BROKEN: {0}", node.ToFullString().Replace(Environment.NewLine, " "));
wroteHeader = true;
}
Console.WriteLine(" ERROR: {0}: {1}", error.Id, error.GetMessage());
}
#pragma warning restore CS0162
suppress = true;
break;
}
}
SyntaxNode updated = base.VisitExpressionStatement(node);
if (suppress)
{
updated = SyntaxFactory.EmptyStatement(
SyntaxFactory.Token(
node.GetLeadingTrivia(),
node.SemicolonToken.Kind(),
node.GetTrailingTrivia()));
}
suppress = false;
return(updated);
}
public static async Task <Document> RefactorAsync(
Document document,
UseMethodChainingAnalysis analysis,
ExpressionStatementSyntax expressionStatement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
InvocationExpressionSyntax invocationExpression = GetInvocationExpression(expressionStatement);
SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(invocationExpression);
ITypeSymbol returnType = semanticModel.GetMethodSymbol(invocationExpression, cancellationToken).ReturnType;
string name = ((IdentifierNameSyntax)UseMethodChainingAnalysis.WalkDownMethodChain(invocationInfo).Expression).Identifier.ValueText;
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(expressionStatement);
string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(expressionStatement, cancellationToken);
var sb = new StringBuilder(invocationExpression.ToString());
int j = index;
while (j < statements.Count - 1)
{
StatementSyntax statement = statements[j + 1];
if (!analysis.IsFixableStatement(statement, name, returnType, semanticModel, cancellationToken))
{
break;
}
sb.AppendLine();
sb.Append(indentation);
sb.Append(GetTextToAppend((ExpressionStatementSyntax)statement));
j++;
}
StatementSyntax lastStatement = statements[j];
SyntaxList <StatementSyntax> newStatements = statements;
while (j > index)
{
newStatements = newStatements.RemoveAt(j);
j--;
}
ExpressionSyntax newInvocationExpression = SyntaxFactory.ParseExpression(sb.ToString());
SyntaxTriviaList trailingTrivia = statementsInfo
.Parent
.DescendantTrivia(TextSpan.FromBounds(invocationExpression.Span.End, lastStatement.Span.End))
.ToSyntaxTriviaList()
.EmptyIfWhitespace()
.AddRange(lastStatement.GetTrailingTrivia());
ExpressionStatementSyntax newExpressionStatement = expressionStatement
.ReplaceNode(invocationExpression, newInvocationExpression)
.WithLeadingTrivia(expressionStatement.GetLeadingTrivia())
.WithTrailingTrivia(trailingTrivia)
.WithFormatterAndSimplifierAnnotation();
newStatements = newStatements.ReplaceAt(index, newExpressionStatement);
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (node.ToString().Length < 110)
{
return(base.VisitExpressionStatement(node));
}
var m = node.Expression;
var rewritableToken = new List <SyntaxToken>();
var trivia = new SyntaxTriviaList(SyntaxFactory.EndOfLine("\n"));
trivia = trivia.AddRange(node.GetLeadingTrivia().Reverse()
.TakeWhile(x => x.IsDirective ^ !x.IsKind(SyntaxKind.EndOfLineTrivia)));
trivia = trivia.Add(SyntaxFactory.Whitespace(" "));
var newExpression = SyntaxFactory.ParseExpression("");
while (m != null && m.ChildNodes().Any())
{
var m2 = m.ChildNodes();
if (m2.FirstOrDefault() is MemberAccessExpressionSyntax &&
m2.LastOrDefault() is ArgumentListSyntax)
{
var methodName = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>();
var arguments = m2.LastOrDefault().As <ArgumentListSyntax>();
m = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>()?.Expression;
if (newExpression.ToString() == "")
{
newExpression = SyntaxFactory.InvocationExpression(methodName.Name, arguments)
.WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(methodName.Name, arguments).WithoutTrailingTrivia(),
SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
}
else if (m2.FirstOrDefault() is IdentifierNameSyntax &&
m2.LastOrDefault() is ArgumentListSyntax)
{
var identifierName = m2.FirstOrDefault() as IdentifierNameSyntax;
var arguments = m2.LastOrDefault() as ArgumentListSyntax;
m = null;
if (newExpression.ToString() == "")
{
newExpression = SyntaxFactory.InvocationExpression(identifierName, arguments).WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(identifierName.WithoutTrailingTrivia(), arguments.WithoutTrailingTrivia()),
SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
}
else
{
if (newExpression.ToString() == "")
{
newExpression = m.WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
m.WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
m = null;
}
}
if (m != null)
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
m, SyntaxFactory.IdentifierName(newExpression.ToString()));
}
if (!newExpression.ToFullString().Equals(node.ToFullString()))
{
var lineSpan = node.GetFileLinePosSpan();
AddReport(new ChangesReport(node)
{
LineNumber = lineSpan.StartLinePosition.Line,
Column = lineSpan.StartLinePosition.Character,
Message = "your expression should be multi lined",
Generator = nameof(MultiLineExpressionRewriter)
});
}
return(SyntaxFactory.ExpressionStatement(newExpression)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia()));
}
public override Microsoft.CodeAnalysis.SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var expression = node.Expression;
ExpressionStatementSyntax newNode = null;
if (_targetPatternRegEx.Match(node.Expression.ToString()).Success)
{
try
{
// Verify this expression is on line by itself. May not need to do this.
// See if can have multiple ExpressionStatements on same line.
if (VNCCA.Helpers.VB.IsOnLineByItself(node))
{
// HACK(crhodes)
// Figure out how to get Helpers to work here.
Messages.AppendLine(String.Format("Removing {0} Method:({1,-35}) {2}",
VNCCA.Helpers.VB.GetContainingContext(node, _configurationOptions),
VNCCA.Helpers.VB.GetContainingMethodName(node),
node.ToString()));
if (_commentOutOnly)
{
List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>();
string existingLeadingTrivia = node.GetLeadingTrivia().ToString();
string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString();
string existingTrailingTrivia = node.GetTrailingTrivia().ToString();
string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString();
string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, "");
newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull));
newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace)));
newTrivia.Add(SyntaxFactory.CommentTrivia("' "));
newNode = node.WithLeadingTrivia(newTrivia);
}
else
{
// This removes the node
newNode = null;
}
}
else
{
Messages.AppendLine(String.Format("node: >{0}< >{1}< Is NOT OnLineByItself", node.ToString(), node.ToFullString()));
newNode = node;
}
}
catch (Exception ex)
{
Messages.AppendLine(string.Format("Ex:{0} InnerEx:{1}", ex.ToString(), ex.InnerException.ToString()));
}
}
else
{
newNode = node;
}
return(newNode);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax syntaxNode)
{
bool?isAssertTF = IsAssertTrueOrFalse(syntaxNode);
if (isAssertTF != null)
{
string firstArg = null, secondArg = null;
var expr = syntaxNode.Expression as InvocationExpressionSyntax;
var firstArgNode = expr.ArgumentList.Arguments.First().Expression;
if (firstArgNode.IsKind(SyntaxKind.LogicalNotExpression))
{
// revert True and False
string fmt = isAssertTF.Value ? AssertFalseNoMsg : AssertTrueNoMsg;
// the first char should be !
// the comments associated with this arg will be lost
firstArg = firstArgNode.ToString().Trim().Substring(1);
if (expr.ArgumentList.Arguments.Count == 2)
{
secondArg = expr.ArgumentList.Arguments.Last().ToString().Trim();
fmt = isAssertTF.Value ? AssertFalse : AssertTrue;
}
return(SyntaxFactory.ParseStatement(syntaxNode.GetLeadingTrivia().ToFullString() +
string.Format(fmt, firstArg, secondArg) +
syntaxNode.GetTrailingTrivia().ToFullString()));
}
else if (firstArgNode.IsKind(SyntaxKind.EqualsExpression) || firstArgNode.IsKind(SyntaxKind.NotEqualsExpression))
{
BinaryExpressionSyntax expr2 = firstArgNode as BinaryExpressionSyntax;
firstArg = expr2.Left.ToString().Trim();
secondArg = expr2.Right.ToString().Trim();
bool isEqual = firstArgNode.IsKind(SyntaxKind.EqualsExpression);
// Assert.True(a==b) || Assert.False(a!=b)
bool positive = isAssertTF.Value && isEqual || !(isAssertTF.Value || isEqual);
var fmt = positive ? AssertEqual : AssertNotEqual;
// special case
if (IsSpecialValue(ref firstArg, ref secondArg, "null"))
{
// Assert.True(cond ==|!= null) || Assert.False(cond ==|!= null)
fmt = positive ? AssertNull : AssertNotNull;
}
else if (IsSpecialValue(ref firstArg, ref secondArg, "true"))
{
// Assert.True(cond ==|!= true) || Assert.False(cond ==|!= true)
fmt = positive ? AssertTrueNoMsg : AssertFalseNoMsg;
}
else if (IsSpecialValue(ref firstArg, ref secondArg, "false"))
{
// Assert.True(cond ==|!= false) || Assert.False(cond ==|!= false)
fmt = positive ? AssertFalseNoMsg : AssertTrueNoMsg;
}
else
{
int v = 0;
// if second is a const (int only for now)
if (int.TryParse(secondArg, out v))
{
// swap
string tmp = firstArg;
firstArg = secondArg;
secondArg = tmp;
}
}
return(SyntaxFactory.ParseStatement(
syntaxNode.GetLeadingTrivia().ToFullString() +
string.Format(fmt, firstArg, secondArg) +
syntaxNode.GetTrailingTrivia().ToFullString()));
}
}
return(base.VisitExpressionStatement(syntaxNode));
}
public static async Task <Document> RefactorAsync(
Document document,
ExpressionStatementSyntax expressionStatement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
INamedTypeSymbol symbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_Text_StringBuilder);
var invocationExpression = (InvocationExpressionSyntax)expressionStatement.Expression;
MemberInvocationExpression memberInvocation = MemberInvocationExpression.Create(invocationExpression);
ExpressionSyntax expression = GetFirstInvocationInMethodChain(memberInvocation, symbol, semanticModel, cancellationToken).Expression;
StatementContainer statementContainer = StatementContainer.Create(expressionStatement);
SyntaxList <StatementSyntax> statements = statementContainer.Statements;
int index = statements.IndexOf(expressionStatement);
string indentation = CSharpFormatter.GetIncreasedIndentation(expressionStatement, cancellationToken).ToString();
var sb = new StringBuilder(invocationExpression.ToString());
int j = index;
while (j < statements.Count - 1)
{
StatementSyntax statement = statements[j + 1];
if (!IsFixable(statement, expression, symbol, semanticModel, cancellationToken))
{
break;
}
sb.AppendLine();
sb.Append(indentation);
sb.Append(GetTextToAppend((ExpressionStatementSyntax)statement, symbol, semanticModel, cancellationToken));
j++;
}
StatementSyntax lastStatement = statements[j];
SyntaxList <StatementSyntax> newStatements = statements;
while (j > index)
{
newStatements = newStatements.RemoveAt(j);
j--;
}
ExpressionSyntax newInvocationExpression = SyntaxFactory.ParseExpression(sb.ToString());
SyntaxTriviaList trailingTrivia = statementContainer
.Node
.DescendantTrivia(TextSpan.FromBounds(invocationExpression.Span.End, lastStatement.Span.End))
.ToSyntaxTriviaList()
.EmptyIfWhitespace()
.AddRange(lastStatement.GetTrailingTrivia());
ExpressionStatementSyntax newExpressionStatement = expressionStatement
.WithExpression(newInvocationExpression)
.WithLeadingTrivia(expressionStatement.GetLeadingTrivia())
.WithTrailingTrivia(trailingTrivia)
.WithFormatterAndSimplifierAnnotations();
newStatements = newStatements.ReplaceAt(index, newExpressionStatement);
return(await document.ReplaceNodeAsync(statementContainer.Node, statementContainer.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false));
}
private async Task <Document> ConvertToAsyncPackageAsync(CodeFixContext context, Diagnostic diagnostic, CancellationToken cancellationToken)
{
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
Compilation?compilation = await context.Document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
Assumes.NotNull(compilation);
SyntaxNode root = await context.Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
BaseTypeSyntax baseTypeSyntax = root.FindNode(diagnostic.Location.SourceSpan).FirstAncestorOrSelf <BaseTypeSyntax>();
ClassDeclarationSyntax classDeclarationSyntax = baseTypeSyntax.FirstAncestorOrSelf <ClassDeclarationSyntax>();
MethodDeclarationSyntax initializeMethodSyntax = classDeclarationSyntax.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.FirstOrDefault(method => method.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.OverrideKeyword)) && method.Identifier.Text == Types.Package.Initialize);
InvocationExpressionSyntax?baseInitializeInvocationSyntax = initializeMethodSyntax?.Body?.DescendantNodes()
.OfType <InvocationExpressionSyntax>()
.FirstOrDefault(ies => ies.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name?.Identifier.Text == Types.Package.Initialize && memberAccess.Expression is BaseExpressionSyntax);
var getServiceInvocationsSyntax = new List <InvocationExpressionSyntax>();
AttributeSyntax?packageRegistrationSyntax = null;
{
INamedTypeSymbol userClassSymbol = semanticModel.GetDeclaredSymbol(classDeclarationSyntax, context.CancellationToken);
INamedTypeSymbol packageRegistrationType = compilation.GetTypeByMetadataName(Types.PackageRegistrationAttribute.FullName);
AttributeData? packageRegistrationInstance = userClassSymbol?.GetAttributes().FirstOrDefault(a => Equals(a.AttributeClass, packageRegistrationType));
if (packageRegistrationInstance?.ApplicationSyntaxReference != null)
{
packageRegistrationSyntax = (AttributeSyntax)await packageRegistrationInstance.ApplicationSyntaxReference.GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
}
}
if (initializeMethodSyntax != null)
{
getServiceInvocationsSyntax.AddRange(
from invocation in initializeMethodSyntax.DescendantNodes().OfType <InvocationExpressionSyntax>()
let memberBinding = invocation.Expression as MemberAccessExpressionSyntax
let identifierName = invocation.Expression as IdentifierNameSyntax
where identifierName?.Identifier.Text == Types.Package.GetService ||
(memberBinding.Name.Identifier.Text == Types.Package.GetService && memberBinding.Expression.IsKind(SyntaxKind.ThisExpression))
select invocation);
}
// Make it easier to track nodes across changes.
var nodesToTrack = new List <SyntaxNode?>
{
baseTypeSyntax,
initializeMethodSyntax,
baseInitializeInvocationSyntax,
packageRegistrationSyntax,
};
nodesToTrack.AddRange(getServiceInvocationsSyntax);
nodesToTrack.RemoveAll(n => n == null);
SyntaxNode updatedRoot = root.TrackNodes(nodesToTrack);
// Replace the Package base type with AsyncPackage
baseTypeSyntax = updatedRoot.GetCurrentNode(baseTypeSyntax);
SimpleBaseTypeSyntax asyncPackageBaseTypeSyntax = SyntaxFactory.SimpleBaseType(Types.AsyncPackage.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation))
.WithLeadingTrivia(baseTypeSyntax.GetLeadingTrivia())
.WithTrailingTrivia(baseTypeSyntax.GetTrailingTrivia());
updatedRoot = updatedRoot.ReplaceNode(baseTypeSyntax, asyncPackageBaseTypeSyntax);
// Update the PackageRegistration attribute
if (packageRegistrationSyntax != null)
{
LiteralExpressionSyntax trueExpression = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression);
packageRegistrationSyntax = updatedRoot.GetCurrentNode(packageRegistrationSyntax);
AttributeArgumentSyntax allowsBackgroundLoadingSyntax = packageRegistrationSyntax.ArgumentList.Arguments.FirstOrDefault(a => a.NameEquals?.Name?.Identifier.Text == Types.PackageRegistrationAttribute.AllowsBackgroundLoading);
if (allowsBackgroundLoadingSyntax != null)
{
updatedRoot = updatedRoot.ReplaceNode(
allowsBackgroundLoadingSyntax,
allowsBackgroundLoadingSyntax.WithExpression(trueExpression));
}
else
{
updatedRoot = updatedRoot.ReplaceNode(
packageRegistrationSyntax,
packageRegistrationSyntax.AddArgumentListArguments(
SyntaxFactory.AttributeArgument(trueExpression).WithNameEquals(SyntaxFactory.NameEquals(Types.PackageRegistrationAttribute.AllowsBackgroundLoading))));
}
}
// Find the Initialize override, if present, and update it to InitializeAsync
if (initializeMethodSyntax != null)
{
IdentifierNameSyntax cancellationTokenLocalVarName = SyntaxFactory.IdentifierName("cancellationToken");
IdentifierNameSyntax progressLocalVarName = SyntaxFactory.IdentifierName("progress");
initializeMethodSyntax = updatedRoot.GetCurrentNode(initializeMethodSyntax);
BlockSyntax newBody = initializeMethodSyntax.Body;
SyntaxTriviaList leadingTrivia = SyntaxFactory.TriviaList(
SyntaxFactory.Comment(@"// When initialized asynchronously, we *may* be on a background thread at this point."),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.Comment(@"// Do any initialization that requires the UI thread after switching to the UI thread."),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.Comment(@"// Otherwise, remove the switch to the UI thread if you don't need it."),
SyntaxFactory.CarriageReturnLineFeed);
ExpressionStatementSyntax switchToMainThreadStatement = SyntaxFactory.ExpressionStatement(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(Types.ThreadHelper.JoinableTaskFactory)),
SyntaxFactory.IdentifierName(Types.JoinableTaskFactory.SwitchToMainThreadAsync)))
.AddArgumentListArguments(SyntaxFactory.Argument(cancellationTokenLocalVarName))))
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
if (baseInitializeInvocationSyntax != null)
{
var baseInitializeAsyncInvocationBookmark = new SyntaxAnnotation();
AwaitExpressionSyntax baseInitializeAsyncInvocationSyntax = SyntaxFactory.AwaitExpression(
baseInitializeInvocationSyntax
.WithLeadingTrivia()
.WithExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.BaseExpression(),
SyntaxFactory.IdentifierName(Types.AsyncPackage.InitializeAsync)))
.AddArgumentListArguments(
SyntaxFactory.Argument(cancellationTokenLocalVarName),
SyntaxFactory.Argument(progressLocalVarName)))
.WithLeadingTrivia(baseInitializeInvocationSyntax.GetLeadingTrivia())
.WithAdditionalAnnotations(baseInitializeAsyncInvocationBookmark);
newBody = newBody.ReplaceNode(initializeMethodSyntax.GetCurrentNode(baseInitializeInvocationSyntax), baseInitializeAsyncInvocationSyntax);
StatementSyntax baseInvocationStatement = newBody.GetAnnotatedNodes(baseInitializeAsyncInvocationBookmark).First().FirstAncestorOrSelf <StatementSyntax>();
newBody = newBody.InsertNodesAfter(
baseInvocationStatement,
new[] { switchToMainThreadStatement.WithLeadingTrivia(switchToMainThreadStatement.GetLeadingTrivia().Insert(0, SyntaxFactory.LineFeed)) });
}
else
{
newBody = newBody.WithStatements(
newBody.Statements.Insert(0, switchToMainThreadStatement));
}
MethodDeclarationSyntax initializeAsyncMethodSyntax = initializeMethodSyntax
.WithIdentifier(SyntaxFactory.Identifier(Types.AsyncPackage.InitializeAsync))
.WithReturnType(Types.Task.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword))
.AddParameterListParameters(
SyntaxFactory.Parameter(cancellationTokenLocalVarName.Identifier).WithType(Types.CancellationToken.TypeSyntax.WithAdditionalAnnotations(Simplifier.Annotation)),
SyntaxFactory.Parameter(progressLocalVarName.Identifier).WithType(Types.IProgress.TypeSyntaxOf(Types.ServiceProgressData.TypeSyntax).WithAdditionalAnnotations(Simplifier.Annotation)))
.WithBody(newBody);
updatedRoot = updatedRoot.ReplaceNode(initializeMethodSyntax, initializeAsyncMethodSyntax);
// Replace GetService calls with GetServiceAsync
getServiceInvocationsSyntax = updatedRoot.GetCurrentNodes <InvocationExpressionSyntax>(getServiceInvocationsSyntax).ToList();
updatedRoot = updatedRoot.ReplaceNodes(
getServiceInvocationsSyntax,
(orig, node) =>
{
InvocationExpressionSyntax invocation = node;
if (invocation.Expression is IdentifierNameSyntax methodName)
{
invocation = invocation.WithExpression(SyntaxFactory.IdentifierName(Types.AsyncPackage.GetServiceAsync));
}
else if (invocation.Expression is MemberAccessExpressionSyntax memberAccess)
{
invocation = invocation.WithExpression(
memberAccess.WithName(SyntaxFactory.IdentifierName(Types.AsyncPackage.GetServiceAsync)));
}
return(SyntaxFactory.ParenthesizedExpression(SyntaxFactory.AwaitExpression(invocation))
.WithAdditionalAnnotations(Simplifier.Annotation));
});
updatedRoot = await Utils.AddUsingTaskEqualsDirectiveAsync(updatedRoot, cancellationToken);
}
Document newDocument = context.Document.WithSyntaxRoot(updatedRoot);
newDocument = await ImportAdder.AddImportsAsync(newDocument, Simplifier.Annotation, cancellationToken : cancellationToken);
return(newDocument);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (node.ToString().Length < 110)
{
return(base.VisitExpressionStatement(node));
}
var m = node.Expression;
List <SyntaxToken> rewritableToken = new List <SyntaxToken>();
var trivia = new SyntaxTriviaList(SyntaxFactory.EndOfLine("\n"));
trivia = trivia.AddRange(node.GetLeadingTrivia().Reverse()
.TakeWhile(x => !x.IsKind(SyntaxKind.EndOfLineTrivia)));
trivia = trivia.Add(SyntaxFactory.Tab);
var newExpression = SyntaxFactory.ParseExpression("");
while (m != null && m.ChildNodes().Any())
{
var m2 = m.ChildNodes();
if (m2.FirstOrDefault() is MemberAccessExpressionSyntax &&
m2.LastOrDefault() is ArgumentListSyntax)
{
var methodName = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>();
var arguments = m2.LastOrDefault().As <ArgumentListSyntax>();
m = m2.FirstOrDefault().As <MemberAccessExpressionSyntax>()?.Expression;
if (newExpression.ToString() == "")
{
newExpression = SyntaxFactory.InvocationExpression(methodName.Name, arguments)
.WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(methodName.Name, arguments).WithoutTrailingTrivia(),
SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
}
else if (m2.FirstOrDefault() is IdentifierNameSyntax &&
m2.LastOrDefault() is ArgumentListSyntax)
{
var identifierName = m2.FirstOrDefault() as IdentifierNameSyntax;
var arguments = m2.LastOrDefault() as ArgumentListSyntax;
m = null;
if (newExpression.ToString() == "")
{
newExpression = SyntaxFactory.InvocationExpression(identifierName, arguments).WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(identifierName.WithoutTrailingTrivia(), arguments.WithoutTrailingTrivia()),
SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
}
else
{
if (newExpression.ToString() == "")
{
newExpression = m.WithoutTrailingTrivia();
}
else
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
m.WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.DotToken).WithLeadingTrivia(trivia), SyntaxFactory.IdentifierName(newExpression.ToString()));
}
m = null;
}
}
if (m != null)
{
newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
m, SyntaxFactory.IdentifierName(newExpression.ToString()));
}
return(SyntaxFactory.ExpressionStatement(newExpression)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia()));
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
SyntaxNode updatedNode = base.VisitExpressionStatement(node);
if (node.Expression.Kind == SyntaxKind.AddAssignExpression ||
node.Expression.Kind == SyntaxKind.SubtractAssignExpression ||
node.Expression.Kind == SyntaxKind.MultiplyAssignExpression ||
node.Expression.Kind == SyntaxKind.DivideAssignExpression)
{
// Print value of the variable on the 'Left' side of
// compound assignement statements encountered.
var compoundAssignmentExpression = (BinaryExpressionSyntax)node.Expression;
StatementSyntax consoleWriteLineStatement =
Syntax.ParseStatement(string.Format("System.Console.WriteLine({0});", compoundAssignmentExpression.Left.ToString()));
updatedNode =
Syntax.Block(Syntax.List<StatementSyntax>(
node.WithLeadingTrivia().WithTrailingTrivia(), // Remove leading and trailing trivia.
consoleWriteLineStatement))
.WithLeadingTrivia(node.GetLeadingTrivia()) // Attach leading trivia from original node.
.WithTrailingTrivia(node.GetTrailingTrivia()); // Attach trailing trivia from original node.
}
return updatedNode;
}
