private static void ApplyObserveEventMethodFix( DocumentEditor editor, AssignmentExpressionSyntax assignment, MethodDeclarationSyntax methodDeclaration, CancellationToken cancellationToken) { var usesArg = false; if (methodDeclaration.ParameterList.Parameters.Any()) { using (var pooled = IdentifierNameWalker.Borrow((SyntaxNode)methodDeclaration.Body ?? methodDeclaration.ExpressionBody)) { foreach (var name in pooled.IdentifierNames) { if (name.Identifier.ValueText == methodDeclaration.ParameterList.Parameters[0].Identifier.ValueText) { if (methodDeclaration.ParameterList.Parameters.Count == 1) { usesArg = true; continue; } return; } if (methodDeclaration.ParameterList.Parameters.Count == 2 && name.Identifier.ValueText == methodDeclaration.ParameterList.Parameters[1] .Identifier.ValueText) { usesArg = true; } } } } var eventSymbol = (IEventSymbol)editor.SemanticModel.GetSymbolSafe(assignment.Left, cancellationToken); var observeSubscribe = GetObservableFromEventString(eventSymbol) .Replace("HANDLERTYPE", eventSymbol.Type.ToMinimalDisplayString(editor.SemanticModel, assignment.SpanStart)) .Replace("ARGTYPE", ArgType(eventSymbol)) .Replace("LEFT", assignment.Left.ToString()) .Replace("LAMBDA", Lambda(methodDeclaration, usesArg)); editor.AddUsing(SystemReactiveLinq) .ReplaceNode( assignment, SyntaxFactory.ParseExpression(observeSubscribe) .WithTriviaFrom(assignment) .WithSimplifiedNames() .WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation)); if (methodDeclaration.ParameterList.Parameters.Count == 2) { editor.RemoveNode(methodDeclaration.ParameterList.Parameters[0]); } if (!usesArg && methodDeclaration.ParameterList.Parameters.Any()) { editor.RemoveNode(methodDeclaration.ParameterList.Parameters.Last()); } }
public async Task <Solution> InlineAndRemoveMethodAsync(InvocationExpressionSyntax invocation, ExpressionSyntax expression) { if (invocation.SyntaxTree == MethodDeclaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, CancellationToken).ConfigureAwait(false); ExpressionSyntax newExpression = RewriteExpression(invocation, expression); editor.ReplaceNode(invocation, newExpression); editor.RemoveNode(MethodDeclaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineMethodAsync(invocation, expression).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(MethodDeclaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(MethodDeclaration, CancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
private void RemoveDeclaration(string variableName, BlockSyntax block, DocumentEditor editor) { var node = block.GetLocalDeclaredVariables().SingleVariable(variableName); var nodeToDelete = node.AncestorsAndSelf().OfType <LocalDeclarationStatementSyntax>().First(); editor.RemoveNode(nodeToDelete); }
private void ReplaceImportStatements() { HashSet <string> alreadyAddedImportsStatements = new HashSet <string>(); IEnumerable <ImportsStatementSyntax> importsStatementNodes = tree.GetRoot().DescendantNodes().OfType <ImportsStatementSyntax>(); foreach (ImportsStatementSyntax oldImportsStatementNode in importsStatementNodes) // iterate over all qualified names in the file { // could be problems if this import statement isn't simple, however even if an alias is used in the import it's still simple SimpleImportsClauseSyntax oldSimpleImportsNode = oldImportsStatementNode.DescendantNodes().OfType <SimpleImportsClauseSyntax>().First(); var oldNamespace = oldSimpleImportsNode.WithoutTrivia().Name.GetText().ToString(); List <namespace_map> namespaces = NSMappingSQLConnector.GetInstance().GetNamespaceMapsFromOldNamespace(TransformProject.sdkId, oldNamespace); if (namespaces != null) { foreach (namespace_map nsMap in namespaces) { var newNamespace = nsMap.new_namespace; if (!alreadyAddedImportsStatements.Contains(newNamespace)) { alreadyAddedImportsStatements.Add(newNamespace); NameSyntax newIdentifierNode = IdentifierName(newNamespace); var newSimpleImportsNode = oldSimpleImportsNode.WithName(newIdentifierNode); SeparatedSyntaxList <ImportsClauseSyntax> simpleImportsList = new SeparatedSyntaxList <ImportsClauseSyntax>().Add(newSimpleImportsNode); ImportsStatementSyntax newImportsStatementNode = ImportsStatement(simpleImportsList).WithTriviaFrom(oldImportsStatementNode); newImportsStatementNode = newImportsStatementNode.WithImportsKeyword(oldImportsStatementNode.ImportsKeyword); documentEditor.InsertAfter(oldImportsStatementNode, newImportsStatementNode); } } documentEditor.RemoveNode(oldImportsStatementNode); } } }
private static void ReplaceWithUsing(DocumentEditor editor, InvocationExpressionSyntax invocation, CancellationToken cancellationToken) { if (DisposeCall.TryGetDisposedRootMember(invocation, editor.SemanticModel, cancellationToken, out var root) && editor.SemanticModel.TryGetSymbol(root, cancellationToken, out ILocalSymbol local) && local.TrySingleDeclaration(cancellationToken, out VariableDeclarationSyntax declaration) && invocation.TryFirstAncestor(out ExpressionStatementSyntax expressionStatement) && declaration.Parent is LocalDeclarationStatementSyntax localDeclarationStatement) { if (expressionStatement.Parent is BlockSyntax finallyBlock && finallyBlock.Parent is FinallyClauseSyntax finallyClause && finallyClause.Parent is TryStatementSyntax tryStatement && !tryStatement.Catches.Any()) { if (declaration.Variables.TrySingle(out var declarator) && declarator.Initializer?.Value.IsKind(SyntaxKind.NullLiteralExpression) == true && tryStatement.Block.Statements.TryFirst(out var statement) && statement is ExpressionStatementSyntax assignExpressionStatement && assignExpressionStatement.Expression is AssignmentExpressionSyntax assignment) { editor.ReplaceNode( tryStatement, SyntaxFactory.UsingStatement( SyntaxFactory.VariableDeclaration( SyntaxFactory.ParseTypeName("var"), SyntaxFactory.SingletonSeparatedList( declarator.WithInitializer(SyntaxFactory.EqualsValueClause(assignment.Right)))), null, tryStatement.Block.WithStatements(tryStatement.Block.Statements.RemoveAt(0)))); editor.RemoveNode(localDeclarationStatement); }
private void ReplaceUsingStatements() { HashSet <string> alreadyAddedUsingStatements = new HashSet <string>(); IEnumerable <UsingDirectiveSyntax> usingDirectiveNodes = tree.GetRoot().DescendantNodes().OfType <UsingDirectiveSyntax>(); foreach (UsingDirectiveSyntax oldUsingDirectiveNode in usingDirectiveNodes) // iterate over all qualified names in the file { var oldNamespace = oldUsingDirectiveNode.Name.GetText().ToString(); List <namespace_map> namespaces = NSMappingSQLConnector.GetInstance().GetNamespaceMapsFromOldNamespace(TransformProject.sdkId, oldNamespace); if (namespaces != null) { foreach (namespace_map nsMap in namespaces) { var newNamespace = nsMap.new_namespace; if (!alreadyAddedUsingStatements.Contains(newNamespace)) { alreadyAddedUsingStatements.Add(newNamespace); NameSyntax newIdentifierNode = IdentifierName(newNamespace); var newUsingDirectiveNode = oldUsingDirectiveNode.WithName(newIdentifierNode); documentEditor.InsertAfter(oldUsingDirectiveNode, newUsingDirectiveNode); } } documentEditor.RemoveNode(oldUsingDirectiveNode); } } }
private static void AddUsingToEndOfBlock(DocumentEditor editor, BlockSyntax block, ExpressionSyntax expression) { foreach (var statementSyntax in block.Statements) { editor.RemoveNode(statementSyntax); } editor.ReplaceNode( block, SyntaxFactory.Block( SyntaxFactory.UsingStatement( declaration: null, expression: GetExpression(), statement: block.WithAdditionalAnnotations(Formatter.Annotation)))); ExpressionSyntax GetExpression() { if (expression is DeclarationExpressionSyntax declaration && declaration.Designation is SingleVariableDesignationSyntax singleVariable) { return(SyntaxFactory.IdentifierName(singleVariable.Identifier)); } return(expression); } }
public virtual async Task <Solution> InlineAndRemoveAsync( SyntaxNode node, ExpressionSyntax expression, CancellationToken cancellationToken = default(CancellationToken)) { if (node.SyntaxTree == Declaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, cancellationToken).ConfigureAwait(false); ExpressionSyntax newExpression = RewriteExpression(node, expression); editor.ReplaceNode(node, newExpression); editor.RemoveNode(Declaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineAsync(node, expression, cancellationToken).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(Declaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(Declaration, cancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
/// <summary> /// Move <paramref name="toMove"></paramref> before <paramref name="statement">.</paramref>. /// </summary> /// <param name="editor">The <see cref="DocumentEditor"/>.</param> /// <param name="toMove">The <see cref="StatementSyntax"/> to move.</param> /// <param name="statement">The <see cref="StatementSyntax"/>.</param> /// <returns>The <see cref="DocumentEditor"/> that was passed in.</returns> public static DocumentEditor MoveAfter(this DocumentEditor editor, StatementSyntax toMove, StatementSyntax statement) { if (editor is null) { throw new ArgumentNullException(nameof(editor)); } if (toMove is null) { throw new ArgumentNullException(nameof(toMove)); } if (statement is null) { throw new ArgumentNullException(nameof(statement)); } editor.RemoveNode(toMove); editor.InsertAfter(statement, ToMove()); return(editor); StatementSyntax ToMove() { if (statement.GetLastToken().IsKind(SyntaxKind.CloseBraceToken)) { return(toMove.WithLeadingLineFeed()); } return(toMove); } }
private static void RemoveMethod(DocumentEditor editor, IMethodSymbol method, MethodDeclarationSyntax declaration, CancellationToken cancellationToken) { if (method.DeclaredAccessibility == Accessibility.Private && method.IsInvokedOnce(editor.SemanticModel, cancellationToken)) { editor.RemoveNode(declaration); } }
private static async Task <Document> RemoveField(Document document, SyntaxNode node, CancellationToken cancellationToken) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); node = editor.Generator.GetDeclaration(node); editor.RemoveNode(node); return(editor.GetChangedDocument()); }
private static async Task <Document> RemoveFinalizerAsync(Document document, SyntaxNode node, CancellationToken cancellationToken) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); // Get the declaration so that we step up to the methodblocksyntax and not the methodstatementsyntax for VB. node = editor.Generator.GetDeclaration(node); editor.RemoveNode(node); return(editor.GetChangedDocument()); }
private static void AddToIf(DocumentEditor editor, IfStatementSyntax ifSetAndRaise, ExpressionStatementSyntax invocation) { if (ifSetAndRaise.Statement is BlockSyntax body) { editor.RemoveNode(invocation); if (body.Statements.Count == 0) { editor.ReplaceNode( body, body.AddStatements(invocation.WithLeadingElasticLineFeed())); } else { editor.InsertAfter(body.Statements.Last(), invocation.WithLeadingElasticLineFeed()); } } else { if (ifSetAndRaise.Statement == null) { editor.RemoveNode(invocation); editor.ReplaceNode( ifSetAndRaise, (x, _) => ((IfStatementSyntax)x) .WithStatement(SyntaxFactory.Block(ifSetAndRaise.Statement, invocation)) .WithSimplifiedNames() .WithTrailingElasticLineFeed() .WithAdditionalAnnotations(Formatter.Annotation)); } else { editor.RemoveNode(invocation); editor.ReplaceNode( ifSetAndRaise.Statement, (x, _) => SyntaxFactory.Block(ifSetAndRaise.Statement, invocation) .WithSimplifiedNames() .WithTrailingElasticLineFeed() .WithAdditionalAnnotations(Formatter.Annotation)); } } editor.FormatNode(ifSetAndRaise); }
private static async Task <Solution> InlineAndRemoveMethodAsync( Document document, ExpressionStatementSyntax expressionStatement, MethodDeclarationSyntax methodDeclaration, StatementSyntax[] statements, ParameterInfo[] parameterInfos, CancellationToken cancellationToken = default(CancellationToken)) { if (expressionStatement.SyntaxTree.Equals(methodDeclaration.SyntaxTree)) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); Solution solution = document.Project.Solution; StatementSyntax[] newStatements = await ReplaceParameterExpressionWithArgumentExpressionAsync( parameterInfos, statements, solution, cancellationToken).ConfigureAwait(false); newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[statements.Length - 1] = newStatements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); if (expressionStatement.Parent.IsKind(SyntaxKind.Block)) { var block = (BlockSyntax)expressionStatement.Parent; BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(block, newBlock); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(methodDeclaration); document = editor.GetChangedDocument(); return(document.Project.Solution); } else { Solution solution = document.Project.Solution; document = await InlineMethodAsync(document, expressionStatement, statements, parameterInfos, cancellationToken).ConfigureAwait(false); DocumentId documentId = solution.GetDocumentId(methodDeclaration.SyntaxTree); solution = document.Project.Solution; return(await RemoveMethodAsync(solution.GetDocument(documentId), methodDeclaration, cancellationToken).ConfigureAwait(false)); } }
private static void AddToExisting(DocumentEditor editor, ExpressionStatementSyntax statement, IFieldSymbol field) { if (TryGetPreviousStatement(out var previous) && TryGetCreateCompositeDisposable(out var compositeDisposableCreation)) { editor.RemoveNode(statement); editor.AddItemToCollectionInitializer( compositeDisposableCreation, statement.Expression, statement.GetTrailingTrivia()); }
public override void RemoveNode(DocumentEditor editor, SyntaxNode node) { if (node.Kind() == SyntaxKind.SimpleAssignmentExpression) { editor.ReplaceNode(node, ((AssignmentExpressionSyntax)node).Right); } else { editor.RemoveNode(node); } }
private void RemoveLocal(ExpressionSyntax expression, DocumentEditor editor) { var variableDeclaration = expression.Ancestors().OfType <VariableDeclarationSyntax>().FirstOrDefault(); if (variableDeclaration == null) { return; } if (variableDeclaration.Variables.Count > 1) { // Remove the appropriate variabledeclarator var declaratorToRemove = expression.Ancestors().OfType <VariableDeclaratorSyntax>().First(); editor.RemoveNode(declaratorToRemove); } else { // Remove the entire variabledeclaration editor.RemoveNode(variableDeclaration.Ancestors().OfType <LocalDeclarationStatementSyntax>().First()); } }
private static void ChangeEventToPublicAndNonStatic( ICodeGenerationService codeGenerationService, DocumentEditor editor, IEventSymbol eventSymbol, SyntaxNode eventDeclaration, DeclarationModifiers modifiers ) { var declaration = editor.Generator.GetDeclaration(eventDeclaration); var isEventHasExplicitAddOrRemoveMethod = (eventSymbol.AddMethod != null && !eventSymbol.AddMethod.IsImplicitlyDeclared) || ( eventSymbol.RemoveMethod != null && !eventSymbol.RemoveMethod.IsImplicitlyDeclared ); // There are three situations here: // 1. Single Event. // 2. Several events exist in one declaration. // 3. Event has add or remove method(user declared). // For situation 1, declaration is EventFieldDeclaration, eventDeclaration is variableDeclaration. // For situation 2, declaration and eventDeclaration are both EventDeclaration, which are same. // For situation 3, it is same as situation 2, but has add or remove method. if (declaration.Equals(eventDeclaration) && !isEventHasExplicitAddOrRemoveMethod) { // Several events are declared in same line var publicAndNonStaticSymbol = CodeGenerationSymbolFactory.CreateEventSymbol( eventSymbol, accessibility: Accessibility.Public, modifiers: modifiers ); var options = new CodeGenerationOptions(generateMethodBodies: false); var publicAndNonStaticSyntax = codeGenerationService.CreateEventDeclaration( publicAndNonStaticSymbol, destination: CodeGenerationDestination.ClassType, options: options ); // Insert a new declaration and remove the original declaration editor.InsertAfter(declaration, publicAndNonStaticSyntax); editor.RemoveNode(eventDeclaration); } else { // Handle both single event and event has add or remove method editor.SetAccessibility(declaration, Accessibility.Public); editor.SetModifiers(declaration, modifiers); } }
private async Task <Document> MakeClassStatic(Document document, ClassDeclarationSyntax classDeclaration, CancellationToken ct) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, ct).ConfigureAwait(false); DeclarationModifiers modifiers = editor.Generator.GetModifiers(classDeclaration); editor.SetModifiers(classDeclaration, modifiers - DeclarationModifiers.Sealed + DeclarationModifiers.Static); SyntaxList <MemberDeclarationSyntax> members = classDeclaration.Members; MemberDeclarationSyntax defaultConstructor = members.FirstOrDefault(m => m.IsDefaultConstructor()); if (defaultConstructor != null) { editor.RemoveNode(defaultConstructor); } return(editor.GetChangedDocument()); }
internal static void MoveOnPropertyChangedInside(this DocumentEditor editor, IfStatementSyntax ifTrySet, ExpressionStatementSyntax onPropertyChanged) { editor.RemoveNode(onPropertyChanged); editor.AddOnPropertyChanged(ifTrySet, OnPropertyChanged()); ExpressionStatementSyntax OnPropertyChanged() { if (onPropertyChanged.HasLeadingTrivia && onPropertyChanged.GetLeadingTrivia() is { } leadingTrivia&& leadingTrivia.TryFirst(out var first) && first.IsKind(SyntaxKind.EndOfLineTrivia)) { onPropertyChanged = onPropertyChanged.WithLeadingTrivia(leadingTrivia.Remove(first)); } return(onPropertyChanged.WithAdditionalAnnotations(Formatter.Annotation)); } }
public virtual async Task <Solution> InlineAndRemoveAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements, CancellationToken cancellationToken = default(CancellationToken)) { if (expressionStatement.SyntaxTree == Declaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, cancellationToken).ConfigureAwait(false); StatementSyntax[] newStatements = RewriteStatements(statements); int count = statements.Count; newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(expressionStatement); if (statementsInfo.Success) { StatementListInfo newStatementsInfo = statementsInfo.WithStatements(statementsInfo.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(statementsInfo.Parent, newStatementsInfo.Parent); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(Declaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineAsync(expressionStatement, statements, cancellationToken).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(Declaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(Declaration, cancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
/// <summary> /// Move <paramref name="toMove"></paramref> before <paramref name="member">.</paramref>. /// </summary> /// <param name="editor">The <see cref="DocumentEditor"/>.</param> /// <param name="toMove">The <see cref="MemberDeclarationSyntax"/> to move.</param> /// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param> /// <returns>The <see cref="DocumentEditor"/> that was passed in.</returns> public static DocumentEditor MoveAfter(this DocumentEditor editor, MemberDeclarationSyntax toMove, MemberDeclarationSyntax member) { if (editor is null) { throw new ArgumentNullException(nameof(editor)); } if (toMove is null) { throw new ArgumentNullException(nameof(toMove)); } if (member is null) { throw new ArgumentNullException(nameof(member)); } editor.RemoveNode(toMove); editor.InsertAfter(member, ToMove()); editor.ReplaceNode(member, Member()); return(editor); MemberDeclarationSyntax ToMove() { return(toMove.AdjustLeadingNewLine(member)); } MemberDeclarationSyntax Member() { if (member.Parent is TypeDeclarationSyntax typeDeclaration) { var index = typeDeclaration.Members.IndexOf(member) - 1; if (typeDeclaration.Members.IndexOf(toMove) == index) { index--; } return(member.AdjustLeadingNewLine(typeDeclaration.Members.ElementAtOrDefault(index))); } return(toMove); } }
private static void AddUsingToEndOfBlock(DocumentEditor editor, BlockSyntax block, ExpressionStatementSyntax statement) { var statements = block.Statements .Where(s => s.SpanStart > statement.SpanStart) .ToArray(); foreach (var statementSyntax in statements) { editor.RemoveNode(statementSyntax); } editor.ReplaceNode( statement, SyntaxFactory.UsingStatement( declaration: null, expression: statement.Expression, statement: SyntaxFactory.Block(SyntaxFactory.List(statements)) .WithAdditionalAnnotations(Formatter.Annotation))); }
public async Task <Solution> InlineAndRemoveMethodAsync( ExpressionStatementSyntax expressionStatement, SyntaxList <StatementSyntax> statements) { if (expressionStatement.SyntaxTree == MethodDeclaration.SyntaxTree) { DocumentEditor editor = await DocumentEditor.CreateAsync(Document, CancellationToken).ConfigureAwait(false); StatementSyntax[] newStatements = RewriteStatements(statements); int count = statements.Count; newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia()); newStatements[count - 1] = newStatements[count - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia()); StatementContainer container; if (StatementContainer.TryCreate(expressionStatement, out container)) { SyntaxNode newNode = container.NodeWithStatements(container.Statements.ReplaceRange(expressionStatement, newStatements)); editor.ReplaceNode(container.Node, newNode); } else { editor.ReplaceNode(expressionStatement, Block(newStatements)); } editor.RemoveNode(MethodDeclaration); return(editor.GetChangedDocument().Solution()); } else { Document newDocument = await InlineMethodAsync(expressionStatement, statements).ConfigureAwait(false); DocumentId documentId = Document.Solution().GetDocumentId(MethodDeclaration.SyntaxTree); newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(MethodDeclaration, CancellationToken).ConfigureAwait(false); return(newDocument.Solution()); } }
private async Task <Solution> RemoveNodes(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { var solution = document.Project.Solution; var pairs = await GetNodesToRemoveAsync(document, diagnostic, cancellationToken).ConfigureAwait(false); foreach (var group in pairs.GroupBy(p => p.Key)) { DocumentEditor editor = await DocumentEditor.CreateAsync(solution.GetDocument(group.Key), cancellationToken).ConfigureAwait(false); // Start removing from bottom to top to keep spans of nodes that are removed later. foreach (var value in group.OrderByDescending(v => v.Value.SpanStart)) { editor.RemoveNode(value.Value); } solution = solution.WithDocumentSyntaxRoot(group.Key, editor.GetChangedRoot()); } return(solution); }
private static void AddUsingToEndOfBlock(DocumentEditor editor, BlockSyntax block, LocalDeclarationStatementSyntax statement) { var statements = block.Statements .Where(s => s.SpanStart > statement.SpanStart) .TakeWhile(s => !(s is LocalFunctionStatementSyntax)) .ToArray(); foreach (var statementSyntax in statements) { editor.RemoveNode(statementSyntax); } editor.ReplaceNode( statement, SyntaxFactory.UsingStatement( declaration: statement.Declaration.WithoutLeadingTrivia(), expression: null, statement: SyntaxFactory.Block(SyntaxFactory.List(statements)) .WithAdditionalAnnotations(Formatter.Annotation)) .WithLeadingTriviaFrom(statement.Declaration)); }
private static void AddUsingToEndOfBlock(DocumentEditor editor, SwitchSectionSyntax switchSection, LocalDeclarationStatementSyntax statement) { var statements = switchSection.Statements .Where(s => s.SpanStart > statement.SpanStart) .Where(s => !(s == switchSection.Statements.Last() && s is BreakStatementSyntax)) .ToArray(); foreach (var statementSyntax in statements) { editor.RemoveNode(statementSyntax); } editor.ReplaceNode( statement, SyntaxFactory.UsingStatement( declaration: statement.Declaration, expression: null, statement: SyntaxFactory.Block(SyntaxFactory.List(statements)) .WithAdditionalAnnotations(Formatter.Annotation))); }
private static void CreateIf(DocumentEditor editor, ExpressionStatementSyntax setAndRaise, ExpressionStatementSyntax invocation) { editor.RemoveNode(setAndRaise); editor.ReplaceNode( invocation, (node, _) => { var code = StringBuilderPool.Borrow() .AppendLine($"if ({setAndRaise.ToFullString().TrimEnd('\r', '\n', ';')})") .AppendLine("{") .AppendLine($" {invocation.ToFullString().TrimEnd('\r', '\n')}") .AppendLine("}") .Return(); return(SyntaxFactory.ParseStatement(code) .WithSimplifiedNames() .WithLeadingElasticLineFeed() .WithTrailingElasticLineFeed() .WithAdditionalAnnotations(Formatter.Annotation)); }); }
private static async Task <Solution> InlineAndRemoveMethodAsync( Document document, InvocationExpressionSyntax invocation, MethodDeclarationSyntax methodDeclaration, ExpressionSyntax expression, ParameterInfo[] parameterInfos, CancellationToken cancellationToken = default(CancellationToken)) { if (invocation.SyntaxTree.Equals(methodDeclaration.SyntaxTree)) { DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); Solution solution = document.Project.Solution; expression = await ReplaceParameterExpressionWithArgumentExpressionAsync(parameterInfos, expression, solution, cancellationToken).ConfigureAwait(false); editor.ReplaceNode(invocation, expression); editor.RemoveNode(methodDeclaration); document = editor.GetChangedDocument(); return(document.Project.Solution); } else { Solution solution = document.Project.Solution; document = await InlineMethodAsync(document, invocation, expression, parameterInfos, cancellationToken).ConfigureAwait(false); DocumentId documentId = solution.GetDocumentId(methodDeclaration.SyntaxTree); solution = document.Project.Solution; return(await RemoveMethodAsync(solution.GetDocument(documentId), methodDeclaration, cancellationToken).ConfigureAwait(false)); } }
private static void ApplyRemoveSetterFix(DocumentEditor editor, AccessorDeclarationSyntax setter) { editor.RemoveNode(setter, SyntaxRemoveOptions.AddElasticMarker); }