private static Task <Document> RefactorAsync( Document document, SingleLocalDeclarationStatementInfo localInfo, SemanticModel semanticModel, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localInfo.Statement); var localSymbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(localInfo.Declarator, cancellationToken); IdentifierNameSyntax identifierName = FindLastReference(localSymbol, statementsInfo.Parent, semanticModel, cancellationToken); TextSpan span; if (identifierName == null) { span = localInfo.Statement.Span; } else { int position = identifierName.SpanStart; span = TextSpan.FromBounds(localInfo.Statement.SpanStart, statementsInfo.First(f => f.Span.Contains(position)).Span.End); } StatementListSelection selectedStatements = StatementListSelection.Create(statementsInfo, span); var refactoring = new WrapStatements.WrapInUsingStatementRefactoring(); return(refactoring.RefactorAsync(document, selectedStatements, cancellationToken)); }
public static async Task ComputeRefactoringAsync( RefactoringContext context, LocalDeclarationStatementSyntax localDeclaration) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration); if (!statementsInfo.Success) { return; } SingleLocalDeclarationStatementInfo localInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo(localDeclaration); if (!localInfo.Success) { return; } if (!context.Span.IsEmptyAndContainedInSpan(localInfo.EqualsToken)) { return; } ExpressionSyntax value = localInfo.Value; if (value == null) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); TypeSyntax type = localInfo.Type; if (type.IsVar) { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(value, context.CancellationToken); if (typeSymbol?.SupportsExplicitDeclaration() != true) { return; } type = typeSymbol.ToMinimalTypeSyntax(semanticModel, type.SpanStart); } else { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken); if (typeSymbol?.IsErrorType() != false) { return; } } context.RegisterRefactoring( "Split declaration and initialization", ct => RefactorAsync(context.Document, localInfo, type, statementsInfo, ct), RefactoringIdentifiers.SplitDeclarationAndInitialization); }
public static Task <Document> RefactorAsync( Document document, AssignmentExpressionSyntax assignmentExpression, CancellationToken cancellationToken) { var statement = (StatementSyntax)assignmentExpression.Parent; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); statements = statements.RemoveAt(index); var returnStatement = (ReturnStatementSyntax)statement.NextStatement(); IEnumerable <SyntaxTrivia> trivia = statementsInfo .Parent .DescendantTrivia(TextSpan.FromBounds(statement.SpanStart, returnStatement.SpanStart)) .Where(f => !f.IsWhitespaceOrEndOfLineTrivia()); trivia = statement .GetLeadingTrivia() .Concat(trivia); returnStatement = returnStatement .WithExpression(assignmentExpression.Right.WithTriviaFrom(returnStatement.Expression)) .WithLeadingTrivia(trivia); statements = statements.ReplaceAt(index, returnStatement); return(document.ReplaceStatementsAsync(statementsInfo, statements, cancellationToken)); }
private static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); var methodDeclaration = (MethodDeclarationSyntax)statementsInfo.Parent.Parent; SyntaxToken asyncKeyword = methodDeclaration.Modifiers.Find(SyntaxKind.AsyncKeyword); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = methodDeclaration.Identifier.ValueText; name = NameGenerator.Default.EnsureUniqueLocalName(name, semanticModel, statement.SpanStart, cancellationToken: cancellationToken); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); List <StatementSyntax> localFunctionStatements = statements.Skip(index).ToList(); localFunctionStatements[0] = localFunctionStatements[0].TrimLeadingTrivia(); LocalFunctionStatementSyntax localFunction = LocalFunctionStatement( (asyncKeyword.IsKind(SyntaxKind.AsyncKeyword)) ? TokenList(SyntaxKind.AsyncKeyword) : default,
private static Task <Document> RefactorAsync( Document document, IfStatementSyntax ifStatement, StatementListSelection selectedStatements, CancellationToken cancellationToken) { int count = selectedStatements.Count; StatementSyntax newStatement; if (count == 1 && !ifStatement.AsCascade().Any(f => f.Statement?.Kind() == SyntaxKind.Block)) { newStatement = selectedStatements.First(); } else { newStatement = SyntaxFactory.Block(selectedStatements); } ElseClauseSyntax elseClause = SyntaxFactory.ElseClause(newStatement).WithFormatterAnnotation(); IfStatementSyntax lastIfStatement = ifStatement.AsCascade().Last(); IfStatementSyntax newIfStatement = ifStatement.ReplaceNode( lastIfStatement, lastIfStatement.WithElse(elseClause)); SyntaxList <StatementSyntax> newStatements = selectedStatements .UnderlyingList .Replace(ifStatement, newIfStatement) .RemoveRange(selectedStatements.FirstIndex, count); return(document.ReplaceStatementsAsync(SyntaxInfo.StatementListInfo(selectedStatements), newStatements, cancellationToken)); }
private static Task <Document> IfReturnToReturnWithConditionalExpressionAsync( Document document, IfReturnToReturnWithConditionalExpressionAnalysis analysis, CancellationToken cancellationToken = default) { IfStatementSyntax ifStatement = analysis.IfStatement; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(ifStatement); ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(ifStatement.Condition, analysis.Expression1, analysis.Expression2); StatementSyntax newStatement = ReturnStatement(conditionalExpression) .WithLeadingTrivia(ifStatement.GetLeadingTrivia()) .WithTrailingTrivia(statements[index + 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index, newStatement); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
private static Task <Document> DuplicateStatementAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); if (statementsInfo.Success) { int index = statementsInfo.Statements.IndexOf(statement); if (index == 0 && statementsInfo.Parent is BlockSyntax block && block.OpenBraceToken.GetFullSpanEndLine() == statement.GetFullSpanStartLine()) { statement = statement.PrependToLeadingTrivia(CSharpFactory.NewLine()); } SyntaxList <StatementSyntax> newStatements = statementsInfo.Statements.Insert(index + 1, statement.WithNavigationAnnotation()); StatementListInfo newInfo = statementsInfo.WithStatements(newStatements); return(document.ReplaceNodeAsync(statementsInfo.Parent, newInfo.Parent, cancellationToken)); } else { SyntaxList <StatementSyntax> statements = SyntaxFactory.List(new StatementSyntax[] { statement, statement.WithNavigationAnnotation() }); BlockSyntax block = SyntaxFactory.Block(statements); return(document.ReplaceNodeAsync(statement, block, cancellationToken)); } }
private static Task <Document> ConvertWhileStatementToForStatementAsync( Document document, WhileStatementSyntax whileStatement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(whileStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(whileStatement); SingleLocalDeclarationStatementInfo localInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo((LocalDeclarationStatementSyntax)statements[index - 1]); var block = (BlockSyntax)whileStatement.Statement; var expressionStatement = (ExpressionStatementSyntax)block.Statements.Last(); var postIncrementExpression = (PostfixUnaryExpressionSyntax)expressionStatement.Expression; BlockSyntax newBlock = block.WithStatements(block.Statements.Remove(expressionStatement)); ForStatementSyntax forStatement = CSharpFactory.ForStatement( declaration: localInfo.Declaration.TrimTrivia(), condition: whileStatement.Condition, incrementor: postIncrementExpression.TrimTrivia(), statement: newBlock); forStatement = forStatement .WithLeadingTrivia(localInfo.Statement.GetLeadingTrivia().AddRange(whileStatement.GetLeadingTrivia().EmptyIfWhitespace())) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements.ReplaceRange(index - 1, 2, new StatementSyntax[] { forStatement }); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, LocalFunctionStatementSyntax localFunction, bool copyAfter = true, CancellationToken cancellationToken = default) { StatementListInfo statementsInfos = SyntaxInfo.StatementListInfo(localFunction); SyntaxList <StatementSyntax> statements = statementsInfos.Statements; int index = statements.IndexOf(localFunction); if (index == 0) { if (copyAfter) { if (statementsInfos.ParentAsBlock.OpenBraceToken.GetFullSpanEndLine() == localFunction.GetFullSpanStartLine()) { localFunction = localFunction.WithLeadingTrivia(localFunction.GetLeadingTrivia().Insert(0, NewLine())); } } else { localFunction = localFunction.WithTrailingTrivia(localFunction.GetTrailingTrivia().Add(NewLine())); } } int insertIndex = (copyAfter) ? index + 1 : index; SyntaxList <StatementSyntax> newStatements = statements.Insert(insertIndex, localFunction.WithNavigationAnnotation()); return(document.ReplaceStatementsAsync(statementsInfos, newStatements, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, UsingStatementSyntax usingStatement, CancellationToken cancellationToken = default) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(usingStatement); int index = statementsInfo.Statements.IndexOf(usingStatement); StatementListInfo newStatementsInfo = statementsInfo.RemoveAt(index); var statements = new List <StatementSyntax>() { SyntaxFactory.LocalDeclarationStatement(usingStatement.Declaration) }; statements.AddRange(GetStatements(usingStatement)); if (statements.Count > 0) { statements[0] = statements[0] .WithLeadingTrivia(usingStatement.GetLeadingTrivia()); statements[statements.Count - 1] = statements[statements.Count - 1] .WithTrailingTrivia(usingStatement.GetTrailingTrivia()); } newStatementsInfo = newStatementsInfo.WithStatements(newStatementsInfo.Statements.InsertRange(index, statements)); return(document.ReplaceNodeAsync(statementsInfo.Parent, newStatementsInfo.Parent.WithFormatterAnnotation(), cancellationToken)); }
private static bool NullCheckExists(ExpressionSyntax expression, StatementSyntax statement) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); if (!statementsInfo.Success) { return(false); } SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); if (index >= statements.Count - 1) { return(false); } StatementSyntax nextStatement = statements[index + 1]; if (!(nextStatement is IfStatementSyntax ifStatement)) { return(false); } NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(ifStatement.Condition, NullCheckStyles.NotEqualsToNull); if (!nullCheck.Success) { return(false); } return(CSharpFactory.AreEquivalent(expression, nullCheck.Expression)); }
public static Task <Document> RefactorAsync( Document document, StatementListSelection selectedStatements, CancellationToken cancellationToken = default(CancellationToken)) { ImmutableArray <IfStatementSyntax> ifStatements = selectedStatements.Cast <IfStatementSyntax>().ToImmutableArray(); IfStatementSyntax newIfStatement = IfStatement( BinaryExpression(SyntaxKind.LogicalOrExpression, ifStatements.Select(f => f.Condition)), Block(CreateStatements(ifStatements))); SyntaxList <StatementSyntax> statements = selectedStatements.UnderlyingList; int index = statements.IndexOf(ifStatements[0]); SyntaxList <StatementSyntax> newStatements = statements.Replace( ifStatements[0], newIfStatement .WithLeadingTrivia(ifStatements[0].GetLeadingTrivia()) .WithTrailingTrivia(ifStatements[ifStatements.Length - 1].GetTrailingTrivia())); for (int i = 1; i < ifStatements.Length; i++) { newStatements = newStatements.RemoveAt(index + 1); } return(document.ReplaceStatementsAsync(SyntaxInfo.StatementListInfo(selectedStatements), newStatements, cancellationToken)); }
private static Task <Document> IfReturnToReturnWithBooleanExpressionAsync( Document document, IfReturnToReturnWithBooleanExpressionAnalysis analysis, CancellationToken cancellationToken = default) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(analysis.IfStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(analysis.IfStatement); ExpressionSyntax expression = GetBooleanExpression( analysis.IfStatement.Condition, analysis.Expression1, analysis.Expression2, analysis.SemanticModel, cancellationToken); StatementSyntax newStatement = ReturnStatement(expression) .WithLeadingTrivia(analysis.IfStatement.GetLeadingTrivia()) .WithTrailingTrivia(statements[index + 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index, newStatement); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, ObjectCreationExpressionSyntax objectCreation, StatementListSelection selectedStatements, CancellationToken cancellationToken = default) { ExpressionStatementSyntax[] expressionStatements = selectedStatements .Skip(1) .Cast <ExpressionStatementSyntax>() .ToArray(); StatementSyntax firstStatement = selectedStatements.First(); SyntaxList <StatementSyntax> newStatements = selectedStatements.UnderlyingList.Replace( firstStatement, firstStatement.ReplaceNode( objectCreation, objectCreation.WithInitializer(CreateInitializer(objectCreation, expressionStatements)))); int count = expressionStatements.Length; int index = selectedStatements.FirstIndex + 1; while (count > 0) { newStatements = newStatements.RemoveAt(index); count--; } return(document.ReplaceStatementsAsync(SyntaxInfo.StatementListInfo(selectedStatements), newStatements, cancellationToken)); }
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 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 bool Analyze( SimpleMemberInvocationExpressionInfo invocationInfo, StatementSyntax statement, string name, SemanticModel semanticModel, CancellationToken cancellationToken) { if (statement.SpanOrTrailingTriviaContainsDirectives()) { return(false); } StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); if (!statementsInfo.Success) { return(false); } SyntaxList <StatementSyntax> statements = statementsInfo.Statements; if (statements.Count == 1) { return(false); } IMethodSymbol methodSymbol = semanticModel.GetMethodSymbol(invocationInfo.InvocationExpression, cancellationToken); if (methodSymbol == null) { return(false); } ITypeSymbol returnType = methodSymbol.ReturnType; int i = statements.IndexOf(statement); if (i != 0 && IsFixableStatement(statements[i - 1], name, returnType, semanticModel, cancellationToken)) { return(false); } int j = i; while (j < statements.Count - 1) { if (!IsFixableStatement(statements[j + 1], name, returnType, semanticModel, cancellationToken)) { break; } j++; } return(j > i); }
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)); }
private static void Analyze( SyntaxNodeAnalysisContext context, StatementSyntax containingStatement, SyntaxToken token, StatementSyntax statement) { if (token.IsMissing) { return; } if (statement?.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) != false) { return; } StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(containingStatement); if (!statementsInfo.Success) { return; } SyntaxTree syntaxTree = containingStatement.SyntaxTree; if (!syntaxTree.IsMultiLineSpan(TextSpan.FromBounds(token.SpanStart, statement.SpanStart))) { return; } StatementSyntax nextStatement = containingStatement.NextStatement(); if (nextStatement == null) { return; } if (syntaxTree.GetLineCount(TextSpan.FromBounds(statement.Span.End, nextStatement.SpanStart)) > 2) { return; } SyntaxTrivia trivia = statement .GetTrailingTrivia() .FirstOrDefault(f => f.IsEndOfLineTrivia()); if (!trivia.IsEndOfLineTrivia()) { return; } DiagnosticHelpers.ReportDiagnostic( context, DiagnosticRules.AddEmptyLineAfterEmbeddedStatement, Location.Create(syntaxTree, trivia.Span.WithLength(0))); }
private static Task <Document> IfToReturnWithExpressionAsync( Document document, IfToReturnWithExpressionAnalysis analysis, CancellationToken cancellationToken = default) { ExpressionSyntax expression = analysis.Expression; if (analysis.Invert) { expression = SyntaxInverter.LogicallyInvert(expression, analysis.SemanticModel, cancellationToken); } StatementSyntax statement; if (analysis.IsYield) { statement = YieldReturnStatement(expression); } else { statement = ReturnStatement(expression); } IfStatementSyntax ifStatement = analysis.IfStatement; if (ifStatement.IsSimpleIf()) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(ifStatement); StatementSyntax newNode = statement .WithLeadingTrivia(ifStatement.GetLeadingTrivia()) .WithTrailingTrivia(statements[index + 1].GetTrailingTrivia()) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index, newNode); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); } else { StatementSyntax newNode = statement .WithTriviaFrom(ifStatement) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken)); } }
private static Task <Document> SplitLocalDeclarationAsync( Document document, LocalDeclarationStatementSyntax statement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); SyntaxList <StatementSyntax> newStatements = statementsInfo.Statements.ReplaceRange( statement, SplitLocalDeclaration(statement)); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
private static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); var methodDeclaration = (MethodDeclarationSyntax)statementsInfo.Parent.Parent; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = methodDeclaration.Identifier.ValueText; if (!name.EndsWith("Iterator", StringComparison.Ordinal)) { name += "Iterator"; } name = NameGenerator.Default.EnsureUniqueLocalName(name, semanticModel, statement.SpanStart, cancellationToken: cancellationToken); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); List <StatementSyntax> localFunctionStatements = statements.Skip(index).ToList(); int lastIndex = localFunctionStatements.Count - 1; localFunctionStatements[lastIndex] = localFunctionStatements[lastIndex].WithoutTrailingTrivia(); LocalFunctionStatementSyntax localFunction = LocalFunctionStatement( default(SyntaxTokenList), methodDeclaration.ReturnType.WithoutTrivia(), Identifier(name).WithRenameAnnotation(), ParameterList(), Block(localFunctionStatements).WithTrailingTrivia(statements.Last().GetTrailingTrivia())); localFunction = localFunction.WithFormatterAnnotation(); ReturnStatementSyntax returnStatement = ReturnStatement( Token(SyntaxKind.ReturnKeyword).WithLeadingTrivia(statement.GetLeadingTrivia()), InvocationExpression(IdentifierName(name)), SemicolonToken()); SyntaxList <StatementSyntax> newStatements = statements.ReplaceRange( index, statements.Count - index, new StatementSyntax[] { returnStatement, localFunction }); return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false)); }
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, ExpressionSyntax expression, StatementSyntax statement, CancellationToken cancellationToken) { if (statement.IsEmbedded()) { return(await document.ReplaceNodeAsync(statement, Block(statement, CreateNullCheck(expression)), cancellationToken).ConfigureAwait(false)); } else { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int statementIndex = statements.IndexOf(statement); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ISymbol symbol = (statement is LocalDeclarationStatementSyntax localDeclaration) ? semanticModel.GetDeclaredSymbol(localDeclaration.Declaration.Variables.First(), cancellationToken) : semanticModel.GetSymbol(expression, cancellationToken); int lastStatementIndex = IncludeAllReferencesOfSymbol(symbol, expression.Kind(), statements, statementIndex + 1, semanticModel, cancellationToken); if (lastStatementIndex != -1) { if (lastStatementIndex < statements.Count - 1) { lastStatementIndex = IncludeAllReferencesOfVariablesDeclared(statements, statementIndex + 1, lastStatementIndex, semanticModel, cancellationToken); } return(await RefactorAsync( document, expression, statements, statementsInfo, statementIndex, lastStatementIndex, cancellationToken).ConfigureAwait(false)); } } return(await document.InsertNodeAfterAsync(statement, CreateNullCheck(expression), cancellationToken).ConfigureAwait(false)); }
private static async Task <Document> RefactorAsync( Document document, SwitchStatementSyntax switchStatement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(switchStatement); StatementListInfo newStatementsInfo = await RefactorAsync( document, switchStatement, statementsInfo, CreateNewSwitchStatement, switchStatement.Sections.Count, switchStatement.Sections.Any(f => f.ContainsDefaultLabel()), cancellationToken).ConfigureAwait(false); return(await document.ReplaceNodeAsync(statementsInfo.Parent, newStatementsInfo.Parent, cancellationToken).ConfigureAwait(false)); }
private static Task <Document> RefactorAsync( Document document, StatementListSelection selectedStatements, CancellationToken cancellationToken) { ImmutableArray <IfStatementSyntax> ifStatements = selectedStatements.Cast <IfStatementSyntax>().ToImmutableArray(); SyntaxList <StatementSyntax> newStatements = selectedStatements.UnderlyingList.Replace( ifStatements[0], ifStatements[0] .WithCondition(BinaryExpression(SyntaxKind.LogicalOrExpression, ifStatements.Select(f => f.Condition))) .WithLeadingTrivia(ifStatements[0].GetLeadingTrivia()) .WithTrailingTrivia(ifStatements[ifStatements.Length - 1].GetTrailingTrivia())); newStatements = newStatements.RemoveRange(selectedStatements.FirstIndex + 1, selectedStatements.Count - 1); return(document.ReplaceStatementsAsync(SyntaxInfo.StatementListInfo(selectedStatements), newStatements, cancellationToken)); }
private static Task <Document> ToAssignmentWithConditionalExpressionAsync( Document document, ToAssignmentWithConditionalExpressionAnalysis analysis, StatementSyntax newStatement, CancellationToken cancellationToken = default) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(analysis.IfStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(analysis.IfStatement); SyntaxList <StatementSyntax> newStatements = statements .RemoveAt(index) .ReplaceAt(index - 1, newStatement); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
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 static async Task <Document> RefactorAsync( Document document, IfStatementSyntax ifStatement, SyntaxKind jumpKind, bool recursive, CancellationToken cancellationToken = default(CancellationToken)) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement); SyntaxNode node = statementsInfo.Parent; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var rewriter = new ReduceIfStatementRewriter(jumpKind, recursive, semanticModel, cancellationToken); SyntaxNode newNode = rewriter.Visit(node); return(await document.ReplaceNodeAsync(node, newNode, cancellationToken).ConfigureAwait(false)); }
private static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement); var methodDeclaration = (MethodDeclarationSyntax)statementsInfo.Parent.Parent; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = methodDeclaration.Identifier.ValueText; name = NameGenerator.Default.EnsureUniqueLocalName(name, semanticModel, statement.SpanStart, cancellationToken: cancellationToken); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); List <StatementSyntax> localFunctionStatements = statements.Skip(index).ToList(); localFunctionStatements[0] = localFunctionStatements[0].TrimLeadingTrivia(); LocalFunctionStatementSyntax localFunction = LocalFunctionStatement( default(SyntaxTokenList), methodDeclaration.ReturnType.WithoutTrivia(), Identifier(name).WithRenameAnnotation(), ParameterList(), Block(localFunctionStatements)); ReturnStatementSyntax returnStatement = ReturnStatement( Token(TriviaList(NewLine()), SyntaxKind.ReturnKeyword, TriviaList()), InvocationExpression(IdentifierName(name)), Token(SyntaxTriviaList.Empty, SyntaxKind.SemicolonToken, TriviaList(NewLine(), NewLine()))); SyntaxList <StatementSyntax> newStatements = statements.ReplaceRange( index, statements.Count - index, new StatementSyntax[] { returnStatement.WithFormatterAnnotation(), localFunction.WithFormatterAnnotation() }); return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false)); }