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> 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,
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));
}
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));
}
}
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());
}
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 static BlockSyntax CreateBlock(ImmutableArray <StatementSyntax> statements, LocalDeclarationStatementSyntax localDeclaration)
{
if (statements.Length > 1)
{
var nodes = new List <StatementSyntax>(statements.Skip(1));
nodes[0] = nodes[0].WithLeadingTrivia(
localDeclaration
.GetTrailingTrivia()
.AddRange(nodes[0].GetLeadingTrivia()));
nodes[nodes.Count - 1] = nodes[nodes.Count - 1].WithTrailingTrivia();
return(Block(nodes));
}
return(Block());
}
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));
}
private static Task <Document> RefactorAsync(
Document document,
SingleLocalDeclarationStatementInfo localInfo,
TypeSyntax type,
CancellationToken cancellationToken)
{
LocalDeclarationStatementSyntax localStatement = localInfo.Statement;
StatementsInfo statementsInfo = SyntaxInfo.StatementsInfo(localStatement);
int index = statementsInfo.IndexOf(localStatement);
VariableDeclaratorSyntax declarator = localInfo.Declarator;
VariableDeclaratorSyntax newDeclarator = declarator.WithInitializer(null);
VariableDeclarationSyntax newDeclaration = localInfo.Declaration.ReplaceNode(declarator, newDeclarator);
if (type != null)
{
newDeclaration = newDeclaration.WithType(type.WithTriviaFrom(newDeclaration.Type));
}
LocalDeclarationStatementSyntax newLocalStatement = localStatement
.WithDeclaration(newDeclaration)
.WithTrailingTrivia(NewLine())
.WithFormatterAnnotation();
ExpressionStatementSyntax assignmentStatement = SimpleAssignmentStatement(IdentifierName(localInfo.Identifier), localInfo.Initializer.Value)
.WithTrailingTrivia(localStatement.GetTrailingTrivia())
.WithFormatterAnnotation();
StatementsInfo newStatementsInfo = statementsInfo
.Insert(index + 1, assignmentStatement)
.ReplaceAt(index, newLocalStatement);
return(document.ReplaceStatementsAsync(statementsInfo, newStatementsInfo, cancellationToken));
}
