private static IEnumerable <LocalDeclarationStatementSyntax> SplitLocalDeclaration(LocalDeclarationStatementSyntax statement)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = statement.Declaration.Variables;
LocalDeclarationStatementSyntax statement2 = statement.WithoutTrivia();
for (int i = 0; i < variables.Count; i++)
{
LocalDeclarationStatementSyntax newStatement = LocalDeclarationStatement(
statement2.Modifiers,
VariableDeclaration(
statement2.Declaration.Type,
SingletonSeparatedList(variables[i])));
if (i == 0)
{
newStatement = newStatement.WithLeadingTrivia(statement.GetLeadingTrivia());
}
if (i == variables.Count - 1)
{
newStatement = newStatement.WithTrailingTrivia(statement.GetTrailingTrivia());
}
yield return(newStatement.WithFormatterAnnotation());
}
}
private static async Task <Document> RefactorAsync(
Document document,
ConditionalExpressionSyntax conditionalExpression,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
SemanticModel semanticModel = await document.GetSemanticModelAsync();
var block = (BlockSyntax)localDeclaration.Parent;
LocalDeclarationStatementSyntax newLocalDeclaration = GetNewLocalDeclaration(conditionalExpression, localDeclaration, semanticModel)
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
var variableDeclarator = (VariableDeclaratorSyntax)conditionalExpression.Parent.Parent;
IfStatementSyntax ifStatement = ConvertToIfElseWithAssignment(conditionalExpression, IdentifierName(variableDeclarator.Identifier.ToString()))
.WithTrailingTrivia(localDeclaration.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxList <StatementSyntax> statements = block.Statements
.Replace(localDeclaration, newLocalDeclaration)
.Insert(block.Statements.IndexOf(localDeclaration) + 1, ifStatement);
SyntaxNode newRoot = oldRoot.ReplaceNode(block, block.WithStatements(statements));
return(document.WithSyntaxRoot(newRoot));
}
public SyntaxNode CreateLocalVariableDeclaration(LocalDeclarationStatementSyntax node, string typeToMock)
{
var variable = node.Declaration.Variables.FirstOrDefault();
if (variable == null)
{
return(null);
}
var stubName = variable.Identifier.ValueText;
var stubDefDeclaration = CreateStubDefinitionDeclaration(stubName, typeToMock);
var symbol = node.Declaration.GetTypeSymbol(semanticModel) as INamedTypeSymbol;
var initializerExpression = CreateStubInitializerDeclarations(node, stubName, symbol);
var stubDeclaration = CreateStubDeclaration(node, stubName, variable.Identifier.ValueText);
var statements = new SyntaxList <StatementSyntax>();
statements = statements.AddRange(new StatementSyntax[] { stubDefDeclaration }.Union(initializerExpression).Union(new StatementSyntax[] { SyntaxFactory.LocalDeclarationStatement(stubDeclaration) }));
var wrapper = SyntaxFactory.Block(statements);
wrapper = wrapper.WithOpenBraceToken(SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken)) // to remove scope {}
.WithCloseBraceToken(SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken));
return(wrapper
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed));
}
private static async Task <Document> MergeLocalDeclarationWithReturnStatementAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
ReturnStatementSyntax returnStatement,
BlockSyntax block,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
ReturnStatementSyntax newReturnStatement = returnStatement
.WithExpression(localDeclaration.Declaration.Variables[0].Initializer.Value.WithoutTrivia())
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithTrailingTrivia(returnStatement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
int index = block.Statements.IndexOf(localDeclaration);
SyntaxList <StatementSyntax> newStatements = block.Statements
.RemoveAt(index)
.RemoveAt(index)
.Insert(index, newReturnStatement);
BlockSyntax newBlock = block.WithStatements(newStatements);
SyntaxNode newRoot = oldRoot.ReplaceNode(block, newBlock);
return(document.WithSyntaxRoot(newRoot));
}
public static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
var block = (BlockSyntax)localDeclaration.Parent;
SyntaxList <StatementSyntax> statements = block.Statements;
int index = statements.IndexOf(localDeclaration);
var returnStatement = (ReturnStatementSyntax)statements[index + 1];
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax expression = GetExpressionToInline(localDeclaration, semanticModel, cancellationToken);
ReturnStatementSyntax newReturnStatement = returnStatement
.WithExpression(expression)
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithTrailingTrivia(returnStatement.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.Replace(returnStatement, newReturnStatement)
.RemoveAt(index);
BlockSyntax newBlock = block.WithStatements(newStatements);
return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
var block = (BlockSyntax)localDeclaration.Parent;
SyntaxList <StatementSyntax> statements = block.Statements;
int index = statements.IndexOf(localDeclaration);
var returnStatement = (ReturnStatementSyntax)statements[index + 1];
ReturnStatementSyntax newReturnStatement = returnStatement
.WithExpression(localDeclaration.Declaration.Variables[0].Initializer.Value.WithoutTrivia())
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithTrailingTrivia(returnStatement.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.RemoveAt(index)
.RemoveAt(index)
.Insert(index, newReturnStatement);
BlockSyntax newBlock = block.WithStatements(newStatements);
return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
TypeSyntax type = localDeclaration.Declaration.Type;
LocalDeclarationStatementSyntax newNode = localDeclaration;
if (type.IsVar)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken);
TypeSyntax newType = typeSymbol.ToMinimalTypeSyntax(semanticModel, localDeclaration.SpanStart);
newNode = newNode.ReplaceNode(type, newType.WithTriviaFrom(type));
}
Debug.Assert(!newNode.Modifiers.Any(), newNode.Modifiers.ToString());
if (newNode.Modifiers.Any())
{
newNode = newNode.InsertModifier(SyntaxKind.ConstKeyword, ModifierComparer.Instance);
}
else
{
newNode = newNode
.WithoutLeadingTrivia()
.WithModifiers(TokenList(ConstKeyword().WithLeadingTrivia(newNode.GetLeadingTrivia())));
}
return(await document.ReplaceNodeAsync(localDeclaration, newNode).ConfigureAwait(false));
}
private static async Task <Document> ApplyAddUsingFixAsync(CodeFixContext context, LocalDeclarationStatementSyntax statement, ITypeSymbol type, CancellationToken cancellationToken)
{
var editor = await DocumentEditor.CreateAsync(context.Document, cancellationToken).ConfigureAwait(false);
var containingType = statement.FirstAncestor <TypeDeclarationSyntax>();
var usesUnderscoreNames = containingType.UsesUnderscoreNames(editor.SemanticModel, cancellationToken);
var variableDeclarator = statement.Declaration.Variables[0];
var identifier = variableDeclarator.Identifier;
var field = editor.AddField(
containingType,
usesUnderscoreNames
? "_" + identifier.ValueText
: identifier.ValueText,
Accessibility.Private,
DeclarationModifiers.ReadOnly,
type,
CancellationToken.None);
var fieldAccess = usesUnderscoreNames
? SyntaxFactory.IdentifierName(field.Name())
: SyntaxFactory.ParseExpression($"this.{field.Name()}");
editor.ReplaceNode(
statement,
SyntaxFactory.ExpressionStatement(
(ExpressionSyntax)editor.Generator.AssignmentStatement(
fieldAccess,
variableDeclarator.Initializer.Value))
.WithLeadingTrivia(statement.GetLeadingTrivia())
.WithTrailingTrivia(statement.GetTrailingTrivia()));
return(editor.GetChangedDocument());
}
private static async Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
ConditionalExpressionSyntax conditionalExpression,
CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync().ConfigureAwait(false);
TypeSyntax type = localDeclaration.Declaration.Type;
LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.RemoveNode(conditionalExpression.Parent, SyntaxRemoveOptions.KeepExteriorTrivia);
if (type.IsVar)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(conditionalExpression);
if (typeSymbol?.IsErrorType() == false)
{
newLocalDeclaration = newLocalDeclaration.ReplaceNode(
newLocalDeclaration.Declaration.Type,
typeSymbol.ToMinimalTypeSyntax(semanticModel, type.SpanStart).WithSimplifierAnnotation());
}
}
newLocalDeclaration = newLocalDeclaration
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithFormatterAnnotation();
IfStatementSyntax ifStatement = CreateIfStatement(conditionalExpression)
.WithTrailingTrivia(localDeclaration.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxNode parent = localDeclaration.Parent;
if (parent.IsKind(SyntaxKind.SwitchSection))
{
var section = (SwitchSectionSyntax)parent;
SyntaxList <StatementSyntax> statements = section.Statements;
statements = statements
.Replace(localDeclaration, newLocalDeclaration)
.Insert(statements.IndexOf(localDeclaration) + 1, ifStatement);
return(await document.ReplaceNodeAsync(section, section.WithStatements(statements), cancellationToken).ConfigureAwait(false));
}
else
{
var block = (BlockSyntax)parent;
SyntaxList <StatementSyntax> statements = block.Statements;
statements = statements
.Replace(localDeclaration, newLocalDeclaration)
.Insert(statements.IndexOf(localDeclaration) + 1, ifStatement);
return(await document.ReplaceNodeAsync(block, block.WithStatements(statements), cancellationToken).ConfigureAwait(false));
}
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitLocalDeclarationStatement(node));
}
private static Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
VariableDeclaratorSyntax variableDeclarator = localDeclaration
.Declaration
.Variables
.Single();
ExpressionSyntax expression = variableDeclarator
.Initializer
.Value
.WalkDownParentheses();
AsExpressionInfo asExpressionInfo = SyntaxInfo.AsExpressionInfo(expression);
PrefixUnaryExpressionSyntax newCondition = LogicalNotExpression(
ParenthesizedExpression(
IsPatternExpression(
asExpressionInfo.Expression,
DeclarationPattern(
asExpressionInfo.Type,
SingleVariableDesignation(variableDeclarator.Identifier)))));
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration);
int index = statementsInfo.IndexOf(localDeclaration);
var ifStatement = (IfStatementSyntax)statementsInfo[index + 1];
SyntaxTriviaList leadingTrivia = statementsInfo.Parent
.DescendantTrivia(TextSpan.FromBounds(localDeclaration.SpanStart, ifStatement.SpanStart))
.ToSyntaxTriviaList()
.EmptyIfWhitespace();
leadingTrivia = localDeclaration.GetLeadingTrivia().AddRange(leadingTrivia);
StatementSyntax newStatement = ifStatement.Statement;
if (ifStatement.SingleNonBlockStatementOrDefault() is ReturnStatementSyntax returnStatement &&
returnStatement.Expression?.WalkDownParentheses() is IdentifierNameSyntax identifierName &&
string.Equals(identifierName.Identifier.ValueText, variableDeclarator.Identifier.ValueText, System.StringComparison.Ordinal))
{
newStatement = newStatement.ReplaceNode(returnStatement.Expression, NullLiteralExpression().WithTriviaFrom(returnStatement.Expression));
}
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(newCondition.WithTriviaFrom(ifStatement.Condition))
.WithStatement(newStatement)
.WithLeadingTrivia(leadingTrivia)
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statementsInfo.Statements.ReplaceRange(index, 2, newIfStatement);
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
}
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 override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
node = (LocalDeclarationStatementSyntax)base.VisitLocalDeclarationStatement(node);
if (AttributeMatchUtil.HasTriviaAnnotationSimple(node.GetLeadingTrivia(), CountAttributeName))
{
node = node.WithDeclaration(node.Declaration.WithType(NarrowIntegerType(node.Declaration.Type)));
}
return node;
}
private static async Task <Document> ApplyAddUsingFixAsync(CodeFixContext context, LocalDeclarationStatementSyntax statement, ITypeSymbol type)
{
var editor = await DocumentEditor.CreateAsync(context.Document).ConfigureAwait(false);
var usesUnderscoreNames = editor.SemanticModel.SyntaxTree.GetRoot().UsesUnderscoreNames(editor.SemanticModel, CancellationToken.None);
var identifier = statement.Declaration.Variables[0].Identifier;
var name = usesUnderscoreNames
? "_" + identifier.ValueText
: identifier.ValueText;
var containingType = statement.FirstAncestor <TypeDeclarationSyntax>();
var declaredSymbol = editor.SemanticModel.GetDeclaredSymbol(containingType);
while (declaredSymbol.MemberNames.Contains(name))
{
name += "_";
}
var newField = (FieldDeclarationSyntax)editor.Generator.FieldDeclaration(
name,
accessibility: Accessibility.Private,
modifiers: DeclarationModifiers.ReadOnly,
type: SyntaxFactory.ParseTypeName(type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)));
var members = containingType.Members;
if (members.TryGetFirst(x => x is FieldDeclarationSyntax, out MemberDeclarationSyntax field))
{
editor.InsertBefore(field, new[] { newField });
}
else if (members.TryGetFirst(out field))
{
editor.InsertBefore(field, new[] { newField });
}
else
{
editor.AddMember(containingType, newField);
}
var fieldAccess = usesUnderscoreNames
? SyntaxFactory.IdentifierName(name)
: SyntaxFactory.ParseExpression($"this.{name}");
editor.ReplaceNode(
statement,
SyntaxFactory.ExpressionStatement(
(ExpressionSyntax)editor.Generator.AssignmentStatement(
fieldAccess,
statement.Declaration.Variables[0].Initializer.Value))
.WithLeadingTrivia(statement.GetLeadingTrivia())
.WithTrailingTrivia(statement.GetTrailingTrivia()));
return(editor.GetChangedDocument());
}
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,
ConditionalExpressionSyntax conditionalExpression,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync().ConfigureAwait(false);
LocalDeclarationStatementSyntax newLocalDeclaration = GetNewLocalDeclaration(conditionalExpression, localDeclaration, semanticModel)
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia())
.WithFormatterAnnotation();
var variableDeclarator = (VariableDeclaratorSyntax)conditionalExpression.Parent.Parent;
IfStatementSyntax ifStatement = ReplaceWithIfElseWithAssignment(conditionalExpression, IdentifierName(variableDeclarator.Identifier.ValueText))
.WithTrailingTrivia(localDeclaration.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxNode parent = localDeclaration.Parent;
if (parent.IsKind(SyntaxKind.SwitchSection))
{
var section = (SwitchSectionSyntax)parent;
SyntaxList <StatementSyntax> statements = section.Statements;
statements = statements
.Replace(localDeclaration, newLocalDeclaration)
.Insert(statements.IndexOf(localDeclaration) + 1, ifStatement);
root = root.ReplaceNode(section, section.WithStatements(statements));
}
else
{
var block = (BlockSyntax)parent;
SyntaxList <StatementSyntax> statements = block.Statements;
statements = statements
.Replace(localDeclaration, newLocalDeclaration)
.Insert(statements.IndexOf(localDeclaration) + 1, ifStatement);
root = root.ReplaceNode(block, block.WithStatements(statements));
}
return(document.WithSyntaxRoot(root));
}
private async Task <Document> AddSecureFlags(Document document, Diagnostic diagnostic, CancellationToken cancellationToken, string[] propertyNames)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var variableDeclarator = root.FindToken(diagnostic.Location.SourceSpan.Start).Parent as VariableDeclaratorSyntax;
if (variableDeclarator == null)
{
return(document); //Abort!
}
VariableDeclarationSyntax variableDeclaration = variableDeclarator.Parent as VariableDeclarationSyntax;
LocalDeclarationStatementSyntax parentDeclaration = variableDeclaration.Parent as LocalDeclarationStatementSyntax;
if (variableDeclaration == null || parentDeclaration == null)
{
return(document); //Abort!
}
var identifierCookie = variableDeclaration.Variables[0];
//Building the nodes model
var nodes = new List <SyntaxNode>();
foreach (var property in propertyNames)
{
var newAssignment = SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(identifierCookie.Identifier),
SF.IdentifierName(property))
,
SF.LiteralExpression(SyntaxKind.TrueLiteralExpression)
))
.WithLeadingTrivia(CodeFixUtil.KeepLastLine(parentDeclaration.GetLeadingTrivia()));
/*
* .WithLeadingTrivia(parentDeclaration.GetLeadingTrivia()
* .Insert(0, SF.ElasticEndOfLine(Environment.NewLine))
* );*/
nodes.Add(newAssignment);
}
//Inserting the nodes
var newRoot = root.InsertNodesAfter(parentDeclaration, nodes);
return(document.WithSyntaxRoot(newRoot));
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
node = (LocalDeclarationStatementSyntax)base.VisitLocalDeclarationStatement(node);
if (AttributeMatchUtil.HasTriviaAnnotationSimple(node.GetLeadingTrivia(), WidenAttributeName))
{
if (node.Declaration.Type.IsKind(SyntaxKind.PredefinedType))
{
node = node.WithDeclaration(
node.Declaration.WithType(
WidenType(node.Declaration.Type)).WithTriviaFrom(node.Declaration.Type));
}
}
return(node);
}
private static Task <Document> RefactorAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
VariableDeclaratorSyntax variableDeclarator = localDeclaration
.Declaration
.Variables
.Single();
ExpressionSyntax expression = variableDeclarator
.Initializer
.Value
.WalkDownParentheses();
AsExpressionInfo asExpressionInfo = SyntaxInfo.AsExpressionInfo(expression);
PrefixUnaryExpressionSyntax newCondition = LogicalNotExpression(
ParenthesizedExpression(
IsPatternExpression(
asExpressionInfo.Expression,
DeclarationPattern(
asExpressionInfo.Type,
SingleVariableDesignation(variableDeclarator.Identifier)))));
StatementListInfo statements = SyntaxInfo.StatementListInfo(localDeclaration);
int index = statements.IndexOf(localDeclaration);
var ifStatement = (IfStatementSyntax)statements[index + 1];
SyntaxTriviaList leadingTrivia = localDeclaration
.DescendantTrivia(TextSpan.FromBounds(localDeclaration.SpanStart, ifStatement.SpanStart))
.ToSyntaxTriviaList()
.EmptyIfWhitespace();
leadingTrivia = localDeclaration.GetLeadingTrivia().AddRange(leadingTrivia);
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(newCondition.WithTriviaFrom(ifStatement.Condition))
.WithLeadingTrivia(leadingTrivia);
StatementListInfo newStatements = statements.RemoveAt(index).ReplaceAt(index, newIfStatement);
return(document.ReplaceStatementsAsync(statements, newStatements, cancellationToken));
}
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));
}
private async Task <Document> MakeConstantAsync(Document document, LocalDeclarationStatementSyntax localDeclaration, CancellationToken cancellationToken)
{
var declaration = localDeclaration.Declaration;
var typeName = declaration.Type;
if (typeName.IsVar)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var aliasInfo = semanticModel.GetAliasInfo(typeName);
if (aliasInfo == null)
{
var type = semanticModel.GetTypeInfo(typeName).ConvertedType;
if (type.Name != "var")
{
var newtypeName = SyntaxFactory.ParseTypeName(type.ToDisplayString());
declaration = declaration.WithType(newtypeName);
}
}
}
var @const = SyntaxFactory.Token(SyntaxKind.ConstKeyword)
.WithLeadingTrivia(localDeclaration.GetLeadingTrivia());
var modifiers = localDeclaration.Modifiers.Insert(0, @const);
var newLocalDeclaration = localDeclaration
.WithModifiers(modifiers)
.WithDeclaration(declaration.WithoutLeadingTrivia())
.WithTrailingTrivia(localDeclaration.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = root.ReplaceNode(localDeclaration, newLocalDeclaration);
return(document.WithSyntaxRoot(newRoot));
}
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 Task <Document> UsePatternMatchingAsync(
Document document,
SwitchStatementSyntax switchStatement,
CancellationToken cancellationToken)
{
SyntaxList <SwitchSectionSyntax> newSections = switchStatement.Sections.Select(section =>
{
if (!(section.Labels.Single() is CaseSwitchLabelSyntax label))
{
return(section);
}
SyntaxList <StatementSyntax> statements = section.Statements;
StatementSyntax statement = statements[0];
if (statement is BlockSyntax block)
{
statement = block.Statements.FirstOrDefault();
}
SingleLocalDeclarationStatementInfo localInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo((LocalDeclarationStatementSyntax)statement);
var castExpression = (CastExpressionSyntax)localInfo.Value;
CasePatternSwitchLabelSyntax newLabel = CasePatternSwitchLabel(
DeclarationPattern(
castExpression.Type,
SingleVariableDesignation(localInfo.Identifier)),
label.ColonToken);
SwitchSectionSyntax newSection = section.RemoveStatement(localInfo.Statement);
newSection = newSection.WithLabels(newSection.Labels.ReplaceAt(0, newLabel));
return(newSection.WithFormatterAnnotation());
})
.ToSyntaxList();
ExpressionSyntax expression = switchStatement.Expression;
ExpressionSyntax newExpression = expression;
LocalDeclarationStatementSyntax localDeclaration = null;
if (expression.IsKind(SyntaxKind.InvocationExpression))
{
SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(expression);
newExpression = invocationInfo.Expression;
}
else
{
localDeclaration = (LocalDeclarationStatementSyntax)switchStatement.PreviousStatement();
SingleLocalDeclarationStatementInfo localInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo(localDeclaration);
SimpleMemberInvocationExpressionInfo invocationInfo = SyntaxInfo.SimpleMemberInvocationExpressionInfo(localInfo.Value);
newExpression = invocationInfo.Expression;
}
SwitchStatementSyntax newSwitchStatement = switchStatement
.WithExpression(newExpression.WithTriviaFrom(expression))
.WithSections(newSections);
if (localDeclaration != null)
{
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(switchStatement);
newSwitchStatement = newSwitchStatement.WithLeadingTrivia(localDeclaration.GetLeadingTrivia());
SyntaxList <StatementSyntax> newStatements = statementsInfo.Statements
.Replace(switchStatement, newSwitchStatement)
.RemoveAt(statementsInfo.IndexOf(localDeclaration));
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
}
else
{
return(document.ReplaceNodeAsync(switchStatement, newSwitchStatement, cancellationToken));
}
}
private static async Task <Document> MarkLocalVariableAsConstAsync(
Document document,
LocalDeclarationStatementSyntax localDeclaration,
CancellationToken cancellationToken)
{
TypeSyntax type = localDeclaration.Declaration.Type;
LocalDeclarationStatementSyntax newNode = localDeclaration;
if (type.IsVar)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken);
TypeSyntax newType = typeSymbol.ToMinimalTypeSyntax(semanticModel, localDeclaration.SpanStart, SymbolDisplayFormats.FullName_WithoutNullableReferenceTypeModifier);
newNode = newNode.ReplaceNode(type, newType.WithTriviaFrom(type));
}
Debug.Assert(!newNode.Modifiers.Any(), newNode.Modifiers.ToString());
if (newNode.Modifiers.Any())
{
newNode = newNode.InsertModifier(SyntaxKind.ConstKeyword);
}
else
{
newNode = newNode
.WithoutLeadingTrivia()
.WithModifiers(TokenList(Token(SyntaxKind.ConstKeyword).WithLeadingTrivia(newNode.GetLeadingTrivia())));
}
return(await document.ReplaceNodeAsync(localDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}