public async Task <CompilationUnitSyntax> ComputeRoot(CompilationUnitSyntax root)
{
var variable = _variableDeclaration.Variables.First();
var newVariableDeclaration = _variableDeclaration
.WithVariables(variable.WithInitializer(null).ItemToSeparatedList())
.WithType(await GetVariableType(variable));
var codeBlock = _variableDeclaration.Parent.Parent.As <BlockSyntax>();
var originalPosition = codeBlock.Statements.IndexOf(_variableDeclaration.Parent.As <StatementSyntax>());
var variableIdentifier = variable.Identifier.Text.ToIdentifierName();
var newStatements = codeBlock.Statements
.RemoveAt(originalPosition)
.Insert(originalPosition,
newVariableDeclaration
.ToLocalDeclaration()
.Nicefy())
.Insert(originalPosition + 1,
variableIdentifier.AssignWith(variable.Initializer.Value).Nicefy());
return(root.ReplaceNode(
codeBlock,
codeBlock.WithStatements(newStatements)));
}
public static LocalDeclarationStatementSyntax DeclareLocalVariable(Type variableType, string name,
ExpressionSyntax initValue = null,
VariableDeclarationType variableDeclarationType = VariableDeclarationType.ExplicitType)
{
VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
if (variableType.IsVsArrayType())
{
ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression(variableType.ToTypeSyntax())
.WithArgumentList(SyntaxFactory.ArgumentList());
varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp));
}
else if (initValue != null)
{
varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(initValue));
}
VariableDeclarationSyntax varDeclaration = variableDeclarationType == VariableDeclarationType.InferredType
? SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))
: SyntaxFactory.VariableDeclaration(variableType.ToTypeSyntax());
varDeclaration = varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator));
return(SyntaxFactory.LocalDeclarationStatement(varDeclaration));
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
// only local variables!
var p = node.Parent as LocalDeclarationStatementSyntax;
if (p == null)
{
return(node);
}
if (!NeedsRewrite(node))
{
return(node);
}
var list = new List <VariableDeclaratorSyntax>(node.Variables.Count);
foreach (var v in node.Variables)
{
if (IsGoodVariableName(v.Identifier.Text))
{
list.Add(v);
}
else
{
list.Add(v.WithAdditionalAnnotations(s_markerAnnotation));
_count++;
}
}
return(node.WithVariables(SyntaxFactory.SeparatedList(list)));
}
private static List <BaseFieldDeclarationSyntax> SplitDeclaration(BaseFieldDeclarationSyntax baseFieldDeclaration)
{
var fieldDeclaration = baseFieldDeclaration as FieldDeclarationSyntax;
if (fieldDeclaration != null)
{
VariableDeclarationSyntax declaration = fieldDeclaration.Declaration;
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
VariableDeclaratorSyntax first = variables.First();
var newFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (VariableDeclaratorSyntax variable in variables)
{
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
var newFieldDeclaration = fieldDeclaration.WithDeclaration(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = newFieldDeclaration.GetLeadingTrivia().WithoutDirectiveTrivia();
newFieldDeclaration = newFieldDeclaration.WithLeadingTrivia(triviaList);
}
newFieldDeclarations.Add(newFieldDeclaration);
}
return(newFieldDeclarations);
}
var eventFieldDeclaration = baseFieldDeclaration as EventFieldDeclarationSyntax;
if (eventFieldDeclaration != null)
{
VariableDeclarationSyntax declaration = eventFieldDeclaration.Declaration;
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
var first = variables.First();
var newEventFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (VariableDeclaratorSyntax variable in variables)
{
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
var newEventFieldDeclaration = eventFieldDeclaration.WithDeclaration(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = newEventFieldDeclaration.GetLeadingTrivia().WithoutDirectiveTrivia();
newEventFieldDeclaration = newEventFieldDeclaration.WithLeadingTrivia(triviaList);
}
newEventFieldDeclarations.Add(newEventFieldDeclaration);
}
return(newEventFieldDeclarations);
}
return(null);
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
// determination of the type of the variable(s)
var typeSymbol = (ITypeSymbol)this.SemanticModel.GetSymbolInfo(node.Type).Symbol;
bool changed = false;
// you could declare more than one variable with one expression
SeparatedSyntaxList <VariableDeclaratorSyntax> vs = node.Variables;
// we create a space to improve readability
SyntaxTrivia space = SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ");
for (var i = 0; i < node.Variables.Count; i++)
{
// there is not an initialization
if (this.SemanticModel.GetSymbolInfo(node.Type).Symbol.ToString() == "int" &&
node.Variables[i].Initializer == null)
{
// we create a new espression "42"
// preceded by the space we create earlier
ExpressionSyntax es = SyntaxFactory.ParseExpression("42")
.WithLeadingTrivia(Space);
// basically we create an assignment to the espression we just created
EqualsValueClauseSyntax evc = SyntaxFactory.EqualsValueClause(es)
.WithLeadingTrivia(space);
// we replace the null initializer with ours
vs = vs.Replace(vs.ElementAt(i), vs.ElementAt(i).WithInitializer(evc));
changed = true;
}
// there is an initialization but it's not to 42
if (this.SemanticModel.GetSymbolInfo(node.Type).Symbol.ToString() == "int" &&
node.Variables[i].Initializer != null &&
!node.Variables[i].Initializer.Value.IsEquivalentTo(SyntaxFactory.ParseExpression("42")))
{
ExpressionSyntax es = SyntaxFactory.ParseExpression("42")
.WithLeadingTrivia(Space);
EqualsValueClauseSyntax evc = SyntaxFactory.EqualsValueClause(es);
vs = vs.Replace(vs.ElementAt(i), vs.ElementAt(i).WithInitializer(evc));
changed = true;
}
}
if (changed == true)
{
return(node.WithVariables(vs));
}
return(base.VisitVariableDeclaration(node));
}
static VariableDeclarationSyntax ReplaceStartValue(VariableDeclarationSyntax declaration, ExpressionSyntax newStartValue)
{
if (declaration == null)
{
return(null);
}
var variable = declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(newStartValue));
return(declaration.WithVariables(new SeparatedSyntaxList <VariableDeclaratorSyntax>().Add(variable)));
}
public static FieldDeclarationSyntax DeclareField(TypeSyntax typeSyntax, string name, AccessibilityFlags accessibility)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax);
var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
private static List <BaseFieldDeclarationSyntax> DeclarationSplitter(
Document document,
VariableDeclarationSyntax declaration,
Func <VariableDeclarationSyntax, BaseFieldDeclarationSyntax> declarationFactory,
SyntaxTriviaList declarationTrailingTrivia)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
VariableDeclaratorSyntax first = variables.First();
BaseFieldDeclarationSyntax previous = null;
var newFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (SyntaxNodeOrToken nodeOrToken in variables.GetWithSeparators())
{
if (previous == null)
{
VariableDeclaratorSyntax variable = (VariableDeclaratorSyntax)nodeOrToken.AsNode();
variable = variable.WithIdentifier(variable.Identifier.WithoutLeadingWhitespace());
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
previous = declarationFactory(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = previous.GetLeadingTrivia().WithoutDirectiveTrivia();
previous = previous.WithLeadingTrivia(triviaList);
}
}
else
{
SyntaxToken commaToken = nodeOrToken.AsToken();
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
if (trailingTrivia.Any())
{
if (!trailingTrivia.Last().IsKind(SyntaxKind.EndOfLineTrivia))
{
trailingTrivia = trailingTrivia.WithoutTrailingWhitespace().Add(FormattingHelper.GetNewLineTrivia(document));
}
}
else
{
trailingTrivia = SyntaxTriviaList.Create(FormattingHelper.GetNewLineTrivia(document));
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(trailingTrivia));
previous = null;
}
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(declarationTrailingTrivia));
return(newFieldDeclarations);
}
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
{
var stmt = node.ForStatement;
ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(nodesVisitor);
VariableDeclarationSyntax declaration = null;
ExpressionSyntax id;
if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
{
var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
declaration = SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Single();
declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
}
else
{
var v = (ExpressionSyntax)stmt.ControlVariable.Accept(nodesVisitor);
startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, v, startValue);
id = v;
}
var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(nodesVisitor);
PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
ExpressionSyntax condition;
if (value == null)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
}
else
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
}
if (step == null)
{
step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
}
else
{
step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
}
var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
return(SingleStatement(SyntaxFactory.ForStatement(
declaration,
declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue),
condition,
SyntaxFactory.SingletonSeparatedList(step),
block)));
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
// anonymize variable names in variable declaration
// var varList = new SeparatedSyntaxList<VariableDeclaratorSyntax>();
var varList = new List <VariableDeclaratorSyntax>();
foreach (var varNode in node.Variables)
{
var varName = varNode.Identifier.ValueText;
var newName = RegisterNewReanmedVariable(varName);
varList.Add(varNode.WithIdentifier(SyntaxFactory.Identifier(newName)));
}
var newNode = node.WithVariables(SyntaxFactory.SeparatedList(varList));
return(base.VisitVariableDeclaration(newNode));
}
public static FieldDeclarationSyntax DeclareField(TypeSyntax typeSyntax, string name, AccessibilityFlags accessibility, EqualsValueClauseSyntax defaultValue = null)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax);
var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
if (defaultValue != null)
{
varDeclarator = varDeclarator.WithInitializer(defaultValue);
}
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
public static LocalDeclarationStatementSyntax DeclareLocalVariable(string typeName, string variableName,
ExpressionSyntax initValue = null,
VariableDeclarationType variableDeclarationType = VariableDeclarationType.ExplicitType)
{
VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName));
if (initValue != null)
{
varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(initValue));
}
VariableDeclarationSyntax varDeclaration = variableDeclarationType == VariableDeclarationType.InferredType
? SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))
: SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(typeName));
varDeclaration = varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator));
return(SyntaxFactory.LocalDeclarationStatement(varDeclaration));
}
public static FieldDeclarationSyntax DeclareField(Type fieldType, string name,
AccessibilityFlags accessibility = AccessibilityFlags.Default)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(fieldType.ToTypeSyntax());
VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
if (fieldType.IsVsArrayType())
{
ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression(fieldType.ToTypeSyntax())
.WithArgumentList(SyntaxFactory.ArgumentList());
varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp));
}
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
return(node.WithVariables(
SyntaxFactory.SeparatedList(node
.Variables
.Select(v => {
var symbol = GetMonitorableSymbol(v);
if (symbol == null)
{
return v;
}
return v.WithInitializer(
v.Initializer.WithValue(
InvokeAssignmentMonitor(
symbol,
v,
v.Initializer.Value)));
}))));
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
var changed = false;
// you could declare more than one variable with one expression
var vs = node.Variables;
// we create a space to improve readability
var space = SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ");
for (var i = 0; i < node.Variables.Count; i++)
{
// there is not an initialization or there is an initialization but it's not to 411
if (_semanticModel.GetSymbolInfo(node.Type).Symbol?.ToString() == "int" &&
(node.Variables[i].Initializer == null || (node.Variables[i].Initializer != null
&&
!node.Variables[i].Initializer.Value.IsEquivalentTo(ParseExpression("411")))
))
{
// we create a new expression "411"
var es = ParseExpression("411").WithLeadingTrivia(space);
// basically we create an assignment to the expression we just created
var evc = EqualsValueClause(es).WithLeadingTrivia(space);
// we replace the null initializer with ours
vs = vs.Replace(vs.ElementAt(i), vs.ElementAt(i).WithInitializer(evc));
changed = true;
}
}
if (changed)
{
return(node.WithVariables(vs));
}
return(base.VisitVariableDeclaration(node));
}
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
{
var stmt = node.ForStatement;
ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor);
VariableDeclarationSyntax declaration = null;
ExpressionSyntax id;
if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
{
var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
declaration = CommonConversions.SplitVariableDeclarations(v).Values.Single();
declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
}
else
{
id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor);
var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol;
if (symbol != null && !_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any())
{
declaration = CommonConversions.CreateVariableDeclarationAndAssignment(symbol.Name, startValue);
}
else
{
startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
}
}
var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor);
PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
ExpressionSyntax condition;
// In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop.
// If it could evaluate differently or has side effects, it must be extracted as a variable
var preLoopStatements = new List <SyntaxNode>();
var csToValue = (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor);
if (!_semanticModel.GetConstantValue(stmt.ToValue).HasValue)
{
var loopToVariableName = GetUniqueVariableNameInScope(node, "loopTo");
var loopEndDeclaration = SyntaxFactory.LocalDeclarationStatement(CommonConversions.CreateVariableDeclarationAndAssignment(loopToVariableName, csToValue));
// Does not do anything about porting newline trivia upwards to maintain spacing above the loop
preLoopStatements.Add(loopEndDeclaration);
csToValue = SyntaxFactory.IdentifierName(loopToVariableName);
}
;
if (value == null)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue);
}
else
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue);
}
if (step == null)
{
step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
}
else
{
step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
}
var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));
var forStatementSyntax = SyntaxFactory.ForStatement(
declaration,
declaration != null
? SyntaxFactory.SeparatedList <ExpressionSyntax>()
: SyntaxFactory.SingletonSeparatedList(startValue),
condition,
SyntaxFactory.SingletonSeparatedList(step),
block.UnpackNonNestedBlock());
return(SyntaxFactory.List(preLoopStatements.Concat(new[] { forStatementSyntax })));
}
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
{
var stmt = node.ForStatement;
ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor);
VariableDeclarationSyntax declaration = null;
ExpressionSyntax id;
if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
{
var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
declaration = VisualBasicConverter.SplitVariableDeclarations(v, _nodesVisitor, _semanticModel).Values.Single();
declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
}
else
{
id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor);
var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol;
if (!_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any())
{
var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(symbol.Name), null,
SyntaxFactory.EqualsValueClause(startValue));
declaration = SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax));
}
else
{
startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
}
}
var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor);
PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
ExpressionSyntax condition;
if (value == null)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor));
}
else
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor));
}
if (step == null)
{
step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
}
else
{
step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
}
var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));
return(SingleStatement(SyntaxFactory.ForStatement(
declaration,
declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue),
condition,
SyntaxFactory.SingletonSeparatedList(step),
block.UnpackNonNestedBlock())));
}
private static List <BaseFieldDeclarationSyntax> DeclarationSplitter(
Document document,
VariableDeclarationSyntax declaration,
Func <VariableDeclarationSyntax, BaseFieldDeclarationSyntax> declarationFactory,
SyntaxTriviaList declarationTrailingTrivia)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
VariableDeclaratorSyntax first = variables.First();
BaseFieldDeclarationSyntax previous = null;
var newFieldDeclarations = new List <BaseFieldDeclarationSyntax>(variables.Count);
foreach (SyntaxNodeOrToken nodeOrToken in variables.GetWithSeparators())
{
if (previous == null)
{
VariableDeclaratorSyntax variable = (VariableDeclaratorSyntax)nodeOrToken.AsNode();
variable = variable.WithIdentifier(variable.Identifier.WithoutLeadingWhitespace());
var variableDeclarator = SyntaxFactory.SingletonSeparatedList(variable);
previous = declarationFactory(declaration.WithVariables(variableDeclarator));
if (variable != first)
{
var triviaList = previous.GetLeadingTrivia().WithoutDirectiveTrivia();
// Remove all leading blank lines
var nonBlankLinetriviaIndex = TriviaHelper.IndexOfFirstNonBlankLineTrivia(triviaList);
if (nonBlankLinetriviaIndex > 0)
{
triviaList = triviaList.RemoveRange(0, nonBlankLinetriviaIndex);
}
// Add a blank line if the first line contains a comment.
var nonWhitespaceTriviaIndex = TriviaHelper.IndexOfFirstNonWhitespaceTrivia(triviaList, false);
if (nonWhitespaceTriviaIndex >= 0)
{
switch (triviaList[nonWhitespaceTriviaIndex].Kind())
{
case SyntaxKind.SingleLineCommentTrivia:
case SyntaxKind.MultiLineCommentTrivia:
triviaList = triviaList.Insert(0, SyntaxFactory.CarriageReturnLineFeed);
break;
}
}
previous = previous.WithLeadingTrivia(triviaList);
}
}
else
{
SyntaxToken commaToken = nodeOrToken.AsToken();
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
if (trailingTrivia.Any())
{
if (!trailingTrivia.Last().IsKind(SyntaxKind.EndOfLineTrivia))
{
trailingTrivia = trailingTrivia.WithoutTrailingWhitespace().Add(FormattingHelper.GetNewLineTrivia(document));
}
}
else
{
trailingTrivia = SyntaxTriviaList.Create(FormattingHelper.GetNewLineTrivia(document));
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(trailingTrivia));
previous = null;
}
}
newFieldDeclarations.Add(previous.WithTrailingTrivia(declarationTrailingTrivia));
return(newFieldDeclarations);
}
public static VariableDeclarationSyntax WithVariables(this VariableDeclarationSyntax syntax, params VariableDeclaratorSyntax[] variables)
{
return(syntax.WithVariables(SyntaxFactory.SeparatedList(variables)));
}