457 references to ReplaceNode
Metrics (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Metrics.Legacy (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Microsoft.AspNetCore.App.CodeFixes (7)
Authorization\AddAuthorizationBuilderFixer.cs (1)
139root.ReplaceNode(diagnosticTarget, invocation)));
DetectMismatchedParameterOptionalityFixer.cs (1)
49return document.WithSyntaxRoot(root.ReplaceNode(parameterSyntax, newParam));
Http\HeaderDictionaryAddFixer.cs (2)
75root.ReplaceNode(diagnosticTarget, invocation.WithAdditionalAnnotations(Simplifier.AddImportsAnnotation, annotation)))); 103return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(diagnosticTarget, assignment)));
Http\HeaderDictionaryIndexerFixer.cs (1)
60return document.WithSyntaxRoot(root.ReplaceNode(elementAccessExpressionSyntax, newExpression));
RouteParameterUnusedParameterFixer.cs (1)
98var updatedSyntaxTree = root.ReplaceNode(methodSyntax, updatedMethod);
WebApplicationBuilderFixer.cs (1)
81return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(diagnosticTarget, invocation)));
Microsoft.AspNetCore.Components.Analyzers (1)
ComponentParametersShouldBePublicCodeFixProvider.cs (1)
56var newSyntaxRoot = root.ReplaceNode(declarationNode, updatedDeclarationNode);
Microsoft.AspNetCore.Components.SdkAnalyzers (1)
ComponentParametersShouldBePublicCodeFixProvider.cs (1)
56var newSyntaxRoot = root.ReplaceNode(declarationNode, updatedDeclarationNode);
Microsoft.CodeAnalysis.Analyzers (9)
MetaAnalyzers\Fixers\ApplyDiagnosticAnalyzerAttributeFix.cs (1)
77var newRoot = root.ReplaceNode(classDecl, newClassDecl);
MetaAnalyzers\Fixers\ConfigureGeneratedCodeAnalysisFix.cs (1)
84return document.WithSyntaxRoot(root.ReplaceNode(methodDeclaration, newMethodDeclaration));
MetaAnalyzers\Fixers\DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs (1)
167var newRoot = root.ReplaceNode(literal.Syntax, newLiteral);
MetaAnalyzers\Fixers\EnableConcurrentExecutionFix.cs (1)
69return document.WithSyntaxRoot(root.ReplaceNode(methodDeclaration, newMethodDeclaration));
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
Microsoft.CodeAnalysis.AnalyzerUtilities (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Microsoft.CodeAnalysis.BannedApiAnalyzers (5)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
Microsoft.CodeAnalysis.CodeStyle (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Microsoft.CodeAnalysis.CodeStyle.Fixes (21)
src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (3)
100return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement))); 129return (currentTarget.Parent, currentTarget.Parent.ReplaceNode(currentTarget, currentReplacement).WithAdditionalAnnotations(Simplifier.Annotation)); 232return root.ReplaceNode(newTarget, newReplacement);
src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)
210var newRoot = root.ReplaceNode(oldArgumentList, GenerateNewArgumentList(oldArgumentList, newArguments));
src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (1)
120var newRoot = root.ReplaceNode(docCommentNode, newDocComment.WithAdditionalAnnotations(Formatter.Annotation));
src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)
115var newRoot = root.ReplaceNode(_classNode, updatedClassNode);
src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)
79rootWithCoreMembers.ReplaceNode( 107var finalRoot = root.ReplaceNode(lastGeneratedMember, lastMemberWithComments);
src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)
107var newRoot = root.ReplaceNode(node, newNode);
src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchStatementCodeFixProvider.cs (1)
50var newRoot = root.ReplaceNode(switchNode, newSwitchNode);
src\Analyzers\Core\CodeFixes\RemoveUnnecessaryParentheses\AbstractRemoveUnnecessaryParenthesesCodeFixProvider.cs (1)
44(_, currentRoot, current) => currentRoot.ReplaceNode(current, syntaxFacts.Unparenthesize(current)),
src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)
54(semanticModel, root, diagnostic, current) => root.ReplaceNode(current, SimplifyConditional(semanticModel, diagnostic, current)),
src\Analyzers\Core\CodeFixes\SimplifyLinqExpression\SimplifyLinqExpressionCodeFixProvider.cs (1)
66return innerInvocationExpression.ReplaceNode(innerName, outerName.WithTriviaFrom(innerName)).WithTrailingTrivia(current.GetTrailingTrivia());
src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)
265var newPropertyTreeRoot = propertyTreeRoot.ReplaceNode(propertyDeclaration, updatedProperty);
src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForAssignment\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)
150var updatedLocalDeclaration = localDeclaration.ReplaceNode(variable, updatedVariable);
src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)
276return whenPart.ReplaceNode(memberAccess, 287return whenPart.ReplaceNode(elementAccess,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
Microsoft.CodeAnalysis.CSharp.CodeStyle (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)
177var newRoot = root.ReplaceNode(
Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (44)
src\Analyzers\CSharp\CodeFixes\AddBraces\CSharpAddBracesCodeFixProvider.cs (1)
47return embeddedStatement is null ? currentStatement : currentStatement.ReplaceNode(embeddedStatement, SyntaxFactory.Block(embeddedStatement));
src\Analyzers\CSharp\CodeFixes\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)
120var newRoot = root.ReplaceNode(parenthesizedExpression, parenthesizedExpressionWithClosingParen);
src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)
85var updatedRoot = document.Root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\ConvertToAsync\CSharpConvertToAsyncMethodCodeFixProvider.cs (1)
56var newRoot = oldRoot.ReplaceNode(methodDeclaration, ConvertToAsyncFunction(methodDeclaration));
src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)
412typeDeclaration = typeDeclaration.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\HideBase\HideBaseCodeFixProvider.AddNewKeywordAction.cs (1)
28return document.WithSyntaxRoot(root.ReplaceNode(node, GetNewNode(node, modifierOrder)));
src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (2)
350var updatedTopmostContainer = topmostContainer.ReplaceNode( 351nodeToReplace, nodeToReplace.ReplaceNode(identifier, declarationExpression)
src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)
80root = root.ReplaceNode(returnStatement, yieldStatement);
src\Analyzers\CSharp\CodeFixes\Iterator\CSharpChangeToIEnumerableCodeFixProvider.cs (4)
79newDocument = document.WithSyntaxRoot(root.ReplaceNode(node, newMethodDeclarationSyntax)); 85newDocument = document.WithSyntaxRoot(root.ReplaceNode(node, newOperator)); 90newDocument = document.WithSyntaxRoot(root.ReplaceNode(oldAccessor, oldAccessor.WithType(newReturnType))); 95newDocument = document.WithSyntaxRoot(root.ReplaceNode(oldIndexer, oldIndexer.WithType(newReturnType)));
src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)
185localFunctionWithNewParameters = localFunctionWithNewParameters.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\MakeRefStruct\MakeRefStructCodeFixProvider.cs (1)
74var newRoot = root.ReplaceNode(structDeclaration, newStruct);
src\Analyzers\CSharp\CodeFixes\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyCodeFixProvider.cs (2)
81currentProperty = currentProperty.ReplaceNode( 89return currentProperty.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (4)
215return compilationUnitWithoutBlankLine.ReplaceNode(namespaceDeclaration, namespaceDeclarationWithUsings); 251return compilationUnitWithSeparatorLine.ReplaceNode(firstMember, firstMember.WithPrependedLeadingTrivia(orphanedTrivia)); 346return node.ReplaceNode(firstMember, newFirstMember); 380return node.ReplaceNode(firstMember, newFirstMember);
src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)
88var isWithoutSuppression = updatedNode.ReplaceNode(suppression, withoutSuppression);
src\Analyzers\CSharp\CodeFixes\RemoveInKeyword\RemoveInKeywordCodeFixProvider.cs (1)
63return document.WithSyntaxRoot(root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\RemoveNewModifier\RemoveNewModifierCodeFixProvider.cs (1)
64return document.WithSyntaxRoot(root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastCodeFixProvider.cs (2)
52return currentRoot.ReplaceNode(oldParent, newParent); 65return parenthesizedExpression.ReplaceNode(parenthesizedExpression.Expression, Recurse(parenthesizedExpression.Expression))
src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)
72var newRoot = syntaxRoot.ReplaceNode(defaultLiteral, newExpression.WithTriviaFrom(defaultLiteral));
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (1)
109var updatedRoot = document.Root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)
127var newDocument = document.WithSyntaxRoot(newRoot.ReplaceNode(creationExpression, dummyObjectCreation));
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)
63semanticDocument.Root.ReplaceNode(invocationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)
86semanticDocument.Root.ReplaceNode(invocationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)
64semanticDocument.Root.ReplaceNode(objectCreationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentCodeFixProvider.cs (1)
66var newWhenTrueStatement = whenTrueStatement.ReplaceNode(assignment, newAssignment);
src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)
58(_, currentRoot, defaultExpression) => currentRoot.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseExplicitTypeForConst\UseExplicitTypeForConstCodeFixProvider.cs (1)
67var newRoot = root.ReplaceNode(variableDeclaration.Type, type.GenerateTypeSyntax(allowVar: false));
src\Analyzers\CSharp\CodeFixes\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)
62=> root.ReplaceNode(explicitLambda, ConvertToImplicitlyTypedLambda(explicitLambda));
src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)
76return root.ReplaceNode(objectCreation, implicitObject);
src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (2)
75return currentRoot.ReplaceNode(result.Invocation, updatedNode); 118return invocation.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseObjectInitializer\CSharpUseObjectInitializerCodeFixProvider.cs (1)
55return statement.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpIsAndCastCheckCodeFixProvider.cs (1)
90var newIf = currentIf.ReplaceNode(currentIf.Condition, updatedCondition);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationService.cs (2)
555newBlock = block.ReplaceNode(containingStatement, newContainingStatement); 563return destinationMember.ReplaceNode(block, newBlock);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (1)
96return root.ReplaceNode(firstOuterNamespaceWithUsings, newNamespace);
Microsoft.CodeAnalysis.CSharp.EditorFeatures (3)
AutomaticCompletion\AutomaticLineEnderCommandHandler_Helpers.cs (1)
73var newRoot = root.ReplaceNode(
EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (2)
279var rootWithUpdatedEventHookupExpression = root.ReplaceNode(eventHookupExpression, updatedEventHookupExpression); 307return root.ReplaceNode(container, newContainer);
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (2)
CodeGeneration\SyntaxGeneratorTests.cs (1)
45var newRoot = root.ReplaceNode(statement, replacement);
Diagnostics\FixAllProvider\BatchFixerTests.cs (1)
83var newRoot = root.ReplaceNode(node, newNode);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (8)
Attributes\AttributeTests.cs (5)
751var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 816var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 857var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 898var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 937var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()")));
Semantics\OutVarTests.cs (3)
32499var node1 = node0.ReplaceNode(one, decl); 34328syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree; 34542syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree;
Microsoft.CodeAnalysis.CSharp.Features (97)
AddImport\CSharpAddImportFeatureService.cs (1)
521return nameSyntax.ReplaceNode(aliasQualifiedName, aliasQualifiedName.Name);
CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (3)
373return scope.ReplaceNode( 417var newLabeledStatement = labeledStatement.ReplaceNode(newLocalDeclaration, SyntaxFactory.ParseStatement("")); 418return newScope.ReplaceNode(labeledStatement, newLabeledStatement);
CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (1)
260return root.ReplaceNode(
CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (5)
114var replacement = isPatternExpression.ReplaceNode(containingPattern, rewrittenPattern); 115return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement)); 131return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement)); 137return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement)); 144return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement));
ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)
173var finalRoot = root.ReplaceNode(property, finalProperty);
ConvertBetweenRegularAndVerbatimString\AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (1)
91return document.WithSyntaxRoot(root.ReplaceNode(stringExpression, newStringExpression));
ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (3)
440nodesBeforeLocal = [parentStatement.ReplaceNode(invocationExpression, initializer.WithAdditionalAnnotations(Simplifier.Annotation))]; 453nodesAfterLocal = [parentStatement.ReplaceNode(invocationExpression, variableLocal.WithAdditionalAnnotations(Simplifier.Annotation))]; 598var newParentExpressionStatement = parentStatement.ReplaceNode(_source.WalkUpParentheses(), localFunctionInvocation.WithAdditionalAnnotations(Simplifier.Annotation));
ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)
414var rewrittenRoot = formattedRoot.ReplaceNode(constructor, rewrittenConstructor);
ConvertProgram\ConvertProgramTransform_ProgramMain.cs (2)
54newRoot = newRoot.ReplaceNode(firstGlobalStatement, classDeclaration); 97method = method.ReplaceNode(arrayType.ElementType, PredefinedType(StringKeyword));
ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (1)
207var newRoot = root.ReplaceNode(classDeclaration, newDeclaration);
ConvertToRawString\ConvertStringToRawStringCodeRefactoringProvider.cs (1)
139return document.WithSyntaxRoot(root.ReplaceNode(expression, replacement));
EncapsulateField\CSharpEncapsulateFieldService.cs (2)
62root = root.ReplaceNode(declarator, updatedDeclarator); 75root = root.ReplaceNode(fieldSyntax, fieldSyntax
ExtractMethod\CSharpMethodExtractor.cs (1)
201document = document.WithSyntaxRoot(root.ReplaceNode(originalMethodDefinition, methodDefinition));
ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (2)
1018root.ReplaceNode(methodDefinition, newMethodDefinition), cancellationToken).ConfigureAwait(false); 1126var newRoot = oldRoot.ReplaceNode(returnType, newType.GenerateTypeSyntax(allowVar: false));
ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.ExpressionCodeGenerator.cs (2)
153.ReplaceNode(sourceNode, sourceNode.WithAdditionalAnnotations(sourceNodeAnnotation)) 165return newEnclosingStatement.ReplaceNode(sourceNode, callSignature);
FullyQualify\CSharpFullyQualifyService.cs (2)
65return root.ReplaceNode(usingDirective, newUsingDirective); 68return root.ReplaceNode(simpleName, qualifiedName);
GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (1)
222newRoot = root.ReplaceNode(expressionStatement, declarationStatement);
IntroduceVariable\CSharpIntroduceLocalForExpressionCodeRefactoringProvider.cs (2)
65localDeclaration = localDeclaration.ReplaceNode(value, expression.WithoutLeadingTrivia()); 81deconstruction = deconstruction.ReplaceNode(binary.Right, expression.WithoutLeadingTrivia());
IntroduceVariable\CSharpIntroduceVariableService_IntroduceField.cs (1)
63var newRoot = document.Root.ReplaceNode(oldTypeDeclaration, finalTypeDeclaration);
IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (4)
134document.Root.ReplaceNode(oldLambda, oldLambda.WithBody(newBody))); 261var newRoot = document.Root.ReplaceNode(oldParentingNode, WithBlockBody(oldParentingNode, newBody).WithTriviaFrom(oldParentingNode)); 396root = root.ReplaceNode(root.GetCurrentNode(statement), 420var newRoot = root.ReplaceNode(innermostCommonBlock, finalInnerMostBlock);
IntroduceVariable\CSharpIntroduceVariableService_IntroduceQueryLocal.cs (2)
70var newRoot = document.Root.ReplaceNode(oldInnerMostCommonQuery, finalQuery); 90var newRoot = document.Root.ReplaceNode(oldQuery, newQuery);
ReplaceConditionalWithStatements\CSharpReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)
73localDeclarationStatement = localDeclarationStatement.ReplaceNode( 78return localDeclarationStatement.ReplaceNode(
ReplaceMethodWithProperty\CSharpReplaceMethodWithPropertyService.cs (1)
315return currentInvocation.Expression.ReplaceNode(currentName, newName);
ReplacePropertyWithMethods\CSharpReplacePropertyWithMethodsService.ConvertValueToParamRewriter.cs (2)
29return node.ReplaceNode(node.Name, ConvertToParam(node.Name)) 35? node.ReplaceNode(node.Name, ConvertToParam(node.Name))
ReplacePropertyWithMethods\CSharpReplacePropertyWithMethodsService.ConvertValueToReturnsRewriter.cs (2)
26? node.ReplaceNode(node.Name, ConvertToReturns(node.Name)) 31? node.ReplaceNode(node.Name, ConvertToReturns(node.Name))
SimplifyTypeNames\SimplifyTypeNamesCodeFixProvider.cs (1)
55annotatedexpressionSyntax = annotatedexpressionSyntax.ReplaceNode(right, right.WithAdditionalAnnotations(Simplifier.Annotation));
Snippets\AbstractCSharpTypeSnippetProvider.cs (1)
106var newRoot = root.ReplaceNode(typeDeclaration, newTypeDeclaration.WithAdditionalAnnotations(FindSnippetAnnotation));
Snippets\CSharpIntMainSnippetProvider.cs (1)
61var updatedRoot = root.ReplaceNode(returnStatement, updatedReturnStatement);
Snippets\CSharpSnippetHelpers.cs (2)
56var updatedTargetStatement = targetNode.ReplaceNode(block, updatedBlock); 58var newRoot = root.ReplaceNode(targetNode, updatedTargetStatement);
SplitStringLiteral\StringSplitter.cs (2)
112var newRoot = Document.Root.ReplaceNode(nodeToReplace, splitString); 117var newRoot2 = newRoot.ReplaceNode(rightExpression, newRightExpression);
src\Analyzers\CSharp\CodeFixes\AddBraces\CSharpAddBracesCodeFixProvider.cs (1)
47return embeddedStatement is null ? currentStatement : currentStatement.ReplaceNode(embeddedStatement, SyntaxFactory.Block(embeddedStatement));
src\Analyzers\CSharp\CodeFixes\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)
120var newRoot = root.ReplaceNode(parenthesizedExpression, parenthesizedExpressionWithClosingParen);
src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)
85var updatedRoot = document.Root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\ConvertToAsync\CSharpConvertToAsyncMethodCodeFixProvider.cs (1)
56var newRoot = oldRoot.ReplaceNode(methodDeclaration, ConvertToAsyncFunction(methodDeclaration));
src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)
412typeDeclaration = typeDeclaration.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\HideBase\HideBaseCodeFixProvider.AddNewKeywordAction.cs (1)
28return document.WithSyntaxRoot(root.ReplaceNode(node, GetNewNode(node, modifierOrder)));
src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (2)
350var updatedTopmostContainer = topmostContainer.ReplaceNode( 351nodeToReplace, nodeToReplace.ReplaceNode(identifier, declarationExpression)
src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)
80root = root.ReplaceNode(returnStatement, yieldStatement);
src\Analyzers\CSharp\CodeFixes\Iterator\CSharpChangeToIEnumerableCodeFixProvider.cs (4)
79newDocument = document.WithSyntaxRoot(root.ReplaceNode(node, newMethodDeclarationSyntax)); 85newDocument = document.WithSyntaxRoot(root.ReplaceNode(node, newOperator)); 90newDocument = document.WithSyntaxRoot(root.ReplaceNode(oldAccessor, oldAccessor.WithType(newReturnType))); 95newDocument = document.WithSyntaxRoot(root.ReplaceNode(oldIndexer, oldIndexer.WithType(newReturnType)));
src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)
185localFunctionWithNewParameters = localFunctionWithNewParameters.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\MakeRefStruct\MakeRefStructCodeFixProvider.cs (1)
74var newRoot = root.ReplaceNode(structDeclaration, newStruct);
src\Analyzers\CSharp\CodeFixes\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyCodeFixProvider.cs (2)
81currentProperty = currentProperty.ReplaceNode( 89return currentProperty.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (4)
215return compilationUnitWithoutBlankLine.ReplaceNode(namespaceDeclaration, namespaceDeclarationWithUsings); 251return compilationUnitWithSeparatorLine.ReplaceNode(firstMember, firstMember.WithPrependedLeadingTrivia(orphanedTrivia)); 346return node.ReplaceNode(firstMember, newFirstMember); 380return node.ReplaceNode(firstMember, newFirstMember);
src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)
88var isWithoutSuppression = updatedNode.ReplaceNode(suppression, withoutSuppression);
src\Analyzers\CSharp\CodeFixes\RemoveInKeyword\RemoveInKeywordCodeFixProvider.cs (1)
63return document.WithSyntaxRoot(root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\RemoveNewModifier\RemoveNewModifierCodeFixProvider.cs (1)
64return document.WithSyntaxRoot(root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastCodeFixProvider.cs (2)
52return currentRoot.ReplaceNode(oldParent, newParent); 65return parenthesizedExpression.ReplaceNode(parenthesizedExpression.Expression, Recurse(parenthesizedExpression.Expression))
src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)
72var newRoot = syntaxRoot.ReplaceNode(defaultLiteral, newExpression.WithTriviaFrom(defaultLiteral));
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (1)
109var updatedRoot = document.Root.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)
127var newDocument = document.WithSyntaxRoot(newRoot.ReplaceNode(creationExpression, dummyObjectCreation));
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)
63semanticDocument.Root.ReplaceNode(invocationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)
86semanticDocument.Root.ReplaceNode(invocationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)
64semanticDocument.Root.ReplaceNode(objectCreationExpression, dummyObjectCreation), cancellationToken).ConfigureAwait(false);
src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentCodeFixProvider.cs (1)
66var newWhenTrueStatement = whenTrueStatement.ReplaceNode(assignment, newAssignment);
src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)
58(_, currentRoot, defaultExpression) => currentRoot.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseExplicitTypeForConst\UseExplicitTypeForConstCodeFixProvider.cs (1)
67var newRoot = root.ReplaceNode(variableDeclaration.Type, type.GenerateTypeSyntax(allowVar: false));
src\Analyzers\CSharp\CodeFixes\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)
62=> root.ReplaceNode(explicitLambda, ConvertToImplicitlyTypedLambda(explicitLambda));
src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)
76return root.ReplaceNode(objectCreation, implicitObject);
src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (2)
75return currentRoot.ReplaceNode(result.Invocation, updatedNode); 118return invocation.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UseObjectInitializer\CSharpUseObjectInitializerCodeFixProvider.cs (1)
55return statement.ReplaceNode(
src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpIsAndCastCheckCodeFixProvider.cs (1)
90var newIf = currentIf.ReplaceNode(currentIf.Condition, updatedCondition);
UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)
181var updatedParent = parent.ReplaceNode(declaration, updatedDeclaration) 184return root.ReplaceNode(parent, updatedParent);
UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeRefactoringProvider.cs (1)
202var newRoot = root.ReplaceNode(declaration, updatedDeclaration);
Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests (4)
IOperation\IOperationTests_IVariableDeclaration.cs (4)
1218syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree; 2304syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree; 2365syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree; 2833syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree;
Microsoft.CodeAnalysis.CSharp.NetAnalyzers (21)
Microsoft.CodeQuality.Analyzers\QualityGuidelines\CSharpAvoidDuplicateElementInitializationFixer.cs (1)
59var newRoot = root.ReplaceNode(objectInitializer, objectInitializer.WithExpressions(newElementInitializers));
Microsoft.NetCore.Analyzers\InteropServices\CSharpDynamicInterfaceCastableImplementation.Fixer.cs (1)
61return document.WithSyntaxRoot(root.ReplaceNode(declaration, typeDeclaration));
Microsoft.NetCore.Analyzers\Performance\CSharpCollapseMultiplePathOperations.Fixer.cs (1)
65var newRoot = root.ReplaceNode(invocation, newInvocation);
Microsoft.NetCore.Analyzers\Performance\CSharpDoNotGuardCall.Fixer.cs (2)
55newRoot = root.ReplaceNode(conditionalOperationNode, newConditionalOperationNode); 63newRoot = root.ReplaceNode(conditionalOperationNode, newConditionNode);
Microsoft.NetCore.Analyzers\Performance\CSharpPreferDictionaryTryMethodsOverContainsKeyGuardFixer.cs (1)
156.ReplaceNode(containsKeyAccess.Name, IdentifierName(TryGetValue).WithTriviaFrom(containsKeyAccess.Name))
Microsoft.NetCore.Analyzers\Performance\CSharpPreferHashDataOverComputeHash.Fixer.cs (1)
193root = root.ReplaceNode(root.GetCurrentNode(parent)!, newParent);
Microsoft.NetCore.Analyzers\Performance\CSharpPreferLengthCountIsEmptyOverAny.Fixer.cs (4)
36return root.ReplaceNode(invocation.Parent, newMemberAccess.WithTriviaFrom(invocation.Parent)); 44return root.ReplaceNode(invocation, negatedExpression.WithTriviaFrom(invocation)); 91return root.ReplaceNode(invocation.Parent, binaryExpression.WithTriviaFrom(invocation.Parent)); 94return root.ReplaceNode(invocation, GetBinaryExpression(expression, propertyName, SyntaxKind.NotEqualsExpression).WithTriviaFrom(invocation));
Microsoft.NetCore.Analyzers\Runtime\CSharpSpecifyCultureForToLowerAndToUpper.Fixer.cs (3)
35var newRoot = root.ReplaceNode(invocation, newInvocation); 51var newRoot = root.ReplaceNode(memberAccess, newMemberAccess); 59var newRoot = root.ReplaceNode(memberBinding, newMemberBinding);
Microsoft.NetCore.Analyzers\Runtime\CSharpUseOrdinalStringComparison.Fixer.cs (2)
36SyntaxNode newRoot = root.ReplaceNode(memberAccess, newMemberAccess); 60SyntaxNode newRoot = root.ReplaceNode(invokeParent, newInvoke);
Microsoft.NetCore.Analyzers\Runtime\CSharpUseSpanBasedStringConcat.Fixer.cs (1)
20return invocationSyntax.ReplaceNode(oldNameSyntax, newNameSyntax);
Microsoft.NetCore.Analyzers\Usage\CSharpDoNotCompareSpanToNull.Fixer.cs (1)
30_ => Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(binaryExpression, MakeIsEmptyCheck(binaryExpression)))),
Microsoft.NetCore.Analyzers\Usage\CSharpPreferGenericOverloads.Fixer.cs (3)
61.ReplaceNode( 64.ReplaceNode(invocationContext.Syntax, invocationExpressionSyntax) 73.ReplaceNode(invocationContext.Syntax, invocationExpressionSyntax)
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (3)
Semantics\InitOnlyMemberTests.cs (1)
3142var speculatedMethod = accessorDecl.ReplaceNode(accessorDecl.Body, blockStatement);
Semantics\NullableReferenceTypesTests.cs (1)
146581var newIfStatement = ifStatement.ReplaceNode(cast, replaceWith);
Semantics\SuppressAccessibilityChecksTests.cs (1)
217var speculatedMethod = accessorDecl.ReplaceNode(accessorDecl.Body, blockStatement);
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (17)
Compilation\GetSemanticInfoTests.cs (1)
4877var newStatement = statement.ReplaceNode(statement.Declaration.Variables[0].Initializer.Value, newSyntax);
Compilation\SemanticModelAPITests.cs (16)
1558newEqualsValue = param.ReplaceNode(equalsValue, newEqualsValue).Default; 2092newSyntax = oldSyntax.ReplaceNode(oldSyntax.DescendantNodes().OfType<CastExpressionSyntax>().Single(), newArgument); 2109newSyntax = oldSyntax.ReplaceNode(oldSyntax.DescendantNodes().OfType<CastExpressionSyntax>().Single(), newArgument); 2191var speculatedStatement = statement.ReplaceNode(initializer.Value, SyntaxFactory.ParseExpression("0")); 2225var speculatedStatement = statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("0")); 2233var newSpeculatedStatement = statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("1.1")); 2352var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2448var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2490var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2535var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2567var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2584speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2598speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2638var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2675var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement); 2774var speculatedMethod = methodDecl.ReplaceNode(methodDecl.Body, blockStatement);
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (16)
Syntax\SyntaxAnnotationTests.cs (5)
165var newRoot = tree.GetCompilationUnitRoot().ReplaceNode(node, annotatedNode); 175var twiceAnnotatedRoot = newRoot.ReplaceNode(node2, twiceAnnotatedNode); 289var newRoot = tree.GetCompilationUnitRoot().ReplaceNode(lastChildOfFirstNode, annotatedNode); 542return root.ReplaceNode(oldNodeOrToken.AsNode(), newNodeOrToken.AsNode()); 595newRoot = syntaxTree.GetCompilationUnitRoot().ReplaceNode(nodeOrToken.AsNode(), newNode);
Syntax\SyntaxDiffingTests.cs (2)
319var newRoot = root.ReplaceNode(node, newNode); 381var newRoot = root.ReplaceNode(node, newNode);
Syntax\SyntaxNodeTests.cs (2)
2104var expr2 = bex.ReplaceNode(bex.Right, SyntaxFactory.ParseExpression("c")); 3665root = root.ReplaceNode(ThirdUsingClause, newUsingClause);
Syntax\SyntaxRewriterTests.cs (3)
350Assert.Same(tree, tree.GetCompilationUnitRoot().ReplaceNode(typeName, typeName).SyntaxTree); 351var newRoot = tree.GetCompilationUnitRoot().ReplaceNode(typeName, SyntaxFactory.ParseTypeName("Class2<U>")); 366var newRoot = root.ReplaceNode(before, after);
Syntax\TrackNodeTests.cs (4)
70var replacedExpr = trackedExpr.ReplaceNode(currentA, newA); 85var replacedExpr = trackedExpr.ReplaceNode(currentA, newA); 100var replacedExpr = trackedExpr.ReplaceNode(currentA, SyntaxFactory.IdentifierName("c")); 112var replacedExpr = trackedExpr.ReplaceNode(currentA, SyntaxFactory.IdentifierName("c"));
Microsoft.CodeAnalysis.CSharp.Workspaces (12)
Rename\CSharpRenameRewriterLanguageService.cs (2)
288var speculativeTree = originalNode.SyntaxTree.GetRoot(_cancellationToken).ReplaceNode(originalNode, newNode); 303speculativeTree = originalNode.SyntaxTree.GetRoot(_cancellationToken).ReplaceNode(originalNode, newNode);
Simplification\CSharpSimplificationService.Expander.cs (2)
495replacement = replacement.ReplaceNode( 511replacement = replacement.ReplaceNode(
Simplification\Reducers\CSharpCastReducer.Rewriter.cs (1)
60var reducedAncestor = topmostExpressionAncestor.ReplaceNode(node, reducedNode);
Simplification\Reducers\CSharpMiscellaneousReducer.cs (1)
49var newLambda = oldLambda.ReplaceNode(parameterSyntax, newParameterSyntax);
Simplification\Simplifiers\MemberAccessExpressionSimplifier.cs (1)
81return IsEntirelySimpleNames(parent.ReplaceNode(memberAccessExpression, memberAccessExpression.Name));
Simplification\Simplifiers\NameSimplifier.cs (1)
665var newCastExpression = castExpression.ReplaceNode(castExpression.Type, simplifiedNode);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)
177var newRoot = root.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationService.cs (2)
555newBlock = block.ReplaceNode(containingStatement, newContainingStatement); 563return destinationMember.ReplaceNode(block, newBlock);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (1)
96return root.ReplaceNode(firstOuterNamespaceWithUsings, newNamespace);
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (4)
CodeGeneration\SyntaxGeneratorTests.cs (1)
4901var newRoot = root.ReplaceNode(decl, newDecl);
Formatting\FormattingElasticTriviaTests.cs (1)
114var newRoot = root.ReplaceNode(decl, newDecl);
Formatting\FormattingTreeEditTests.cs (2)
44var root1 = root.ReplaceNode(param, g.AddAttributes(param, g.Attribute("MyAttr"))); 58var root2 = root.ReplaceNode(method, g.AddAttributes(method, g.Attribute("MyAttr")));
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (5)
CodeGeneration\CodeGenerationTests.cs (5)
318testContext.Result = testContext.Document.WithSyntaxRoot((await testContext.Document.GetSyntaxRootAsync()).ReplaceNode(oldSyntax, newSyntax)); 334testContext.Result = testContext.Document.WithSyntaxRoot((await testContext.Document.GetSyntaxRootAsync()).ReplaceNode(oldMemberSyntax, newMemberSyntax)); 560testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(oldNode, newNode)); 579testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, newNode)); 631testContext.Result = testContext.Document.WithSyntaxRoot(testContext.SemanticModel.SyntaxTree.GetRoot().ReplaceNode(declarationNode, updatedDeclarationNode));
Microsoft.CodeAnalysis.Features (73)
AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (1)
76var newRoot = syntaxTree.GetRoot(cancellationToken).ReplaceNode(constructor, newConstructor);
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.LocalSuppressMessageCodeAction.cs (1)
33var newRoot = root.ReplaceNode(TargetNode_TestOnly, newTargetNode);
CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaHelpers.cs (2)
61var newRoot = root.ReplaceNode(nodeWithTokens, newNode); 266root = root.ReplaceNode(subtreeRoot, newSubtreeRoot);
Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)
219root = root.ReplaceNode(replacingNode, replacingNode.WithLeadingTrivia(leadingTriviaToCopy).WithTrailingTrivia(trailingTriviaToCopy));
ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)
76var newRoot = root.ReplaceNode(from, ConvertExpression(from, nullableContext, isReferenceType));
ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)
54root = root.ReplaceNode(root.FindNode(ifSpan, getInnermostNodeForTie: true), @switch);
ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)
77return root.ReplaceNode(Source, Destinations[0]);
ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)
124return document.WithSyntaxRoot(root.ReplaceNode(top, interpolatedString));
ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)
415return interpolation.ReplaceNode(
ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)
111root.ReplaceNode(
EncapsulateField\AbstractEncapsulateFieldService.cs (1)
179document = document.WithSyntaxRoot(fieldDeclaration.SyntaxTree.GetRoot(cancellationToken).ReplaceNode(fieldDeclaration.GetSyntax(cancellationToken),
ExtractClass\ExtractClassWithDialogCodeAction.cs (1)
252currentRoot = currentRoot.ReplaceNode(typeDeclaration,
ExtractMethod\MethodExtractor.CodeGenerator.cs (3)
172var rootWithUpdatedCallSite = this.SemanticDocument.Root.ReplaceNode( 199var finalRoot = documentWithUpdatedCallSite.Root.ReplaceNode(destination, updatedDestination); 229var finalRoot = documentWithUpdatedCallSite.Root.ReplaceNode(destination, newContainer);
GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)
118var newDocument = _document.WithSyntaxRoot(oldRoot.ReplaceNode(oldType, newType));
InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (1)
928var newRoot = root.ReplaceNode(assignmentExpression.Value.Syntax, coalesce);
InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (1)
461otherDocument.Id, otherRoot.ReplaceNode(propertySyntax, withoutThrowNotImplemented));
IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)
336var expressionsWithConditionalAccessors = conditionalRoot.ReplaceNode(invocation, newMethodInvocation);
IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (5)
179return document.WithSyntaxRoot(root.ReplaceNode( 193return document.WithSyntaxRoot(root.ReplaceNode(declarationStatement, usingDeclarationStatement)); 224var newRoot = root.ReplaceNode(expressionStatement, usingStatement); 259return document.WithSyntaxRoot(root.ReplaceNode( 268return document.WithSyntaxRoot(root.ReplaceNode(
IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (1)
103var newRoot = root.ReplaceNode(expressionStatement, localStatement);
InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (8)
553return root.ReplaceNode(ifNode, updatedIf); 565return root.ReplaceNode(ifNode, updatedIf); 576return root.ReplaceNode(ifNode, updatedIf); 619return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 643return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 669return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 702return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 727return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation));
InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (2)
108return document.WithSyntaxRoot(root.ReplaceNode( 134return document.WithSyntaxRoot(root.ReplaceNode(
MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)
312expandedExtensionInvocation = expandedExtensionInvocation.ReplaceNode(typeExpression, generator.TypeExpression(newType)
NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)
87var newRoot = root.ReplaceNode(argument, newArgument);
PullMemberUp\MembersPuller.cs (2)
417return root.ReplaceNode(firstMember, firstMember.WithoutLeadingTrivia()); 425return root.ReplaceNode(firstMember, firstMember.WithLeadingTrivia(trivia));
ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)
214var newRoot = root.ReplaceNode(statement, ifStatement); 299var containerWithConditionalReplaced = container.ReplaceNode(conditionalExpression, TryConvert(expression, conditionalType).WithTriviaFrom(conditionalExpression));
ReplacePropertyWithMethods\AbstractReplacePropertyWithMethodsService.cs (3)
348return _expression.ReplaceNode(_identifierName, newIdentifierName); 372_expression.ReplaceNode(_identifierName, newIdentifierName), 399var updatedExpression = _expression.ReplaceNode(_identifierName, newIdentifierName);
Shared\Extensions\DocumentExtensions.cs (1)
38var newRoot = root.ReplaceNode(oldNode, newNode);
Shared\Utilities\AnnotatedSymbolMapping.cs (1)
61currentRoots[typeNode.SyntaxTree] = typeNodeRoot.ReplaceNode(typeNode, typeNode.WithAdditionalAnnotations(typeNodeAnnotation));
Shared\Utilities\ExtractTypeHelpers.cs (1)
105var annotatedRoot = syntaxRoot.ReplaceNode(declarationNode, declarationNode.WithAdditionalAnnotations(typeAnnotation));
Snippets\SnippetFunctionService.cs (1)
153var updatedRoot = syntaxRoot.ReplaceNode(nodeToReplace, nodeToReplace.WithAdditionalAnnotations(typeAnnotation, Simplifier.Annotation));
Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)
83return root.ReplaceNode(snippetExpressionNode, reformatSnippetNode);
Snippets\SnippetProviders\AbstractSnippetProvider.cs (2)
184root = root.ReplaceNode(nearestStatement, nearestStatementWithTrivia); 216return root.ReplaceNode(snippetExpressionNode, reformatSnippetNode);
SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (1)
107var right = rootExpression.ReplaceNode(token.Parent, parentRight);
SplitOrMergeIfStatements\Nested\AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs (1)
85return root.ReplaceNode(outerIfOrElseIf, newIfOrElseIf.WithAdditionalAnnotations(Formatter.Annotation));
SplitOrMergeIfStatements\Nested\AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs (1)
57root.ReplaceNode(ifOrElseIf, outerIfOrElseIf.WithAdditionalAnnotations(Formatter.Annotation)));
src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (3)
100return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement))); 129return (currentTarget.Parent, currentTarget.Parent.ReplaceNode(currentTarget, currentReplacement).WithAdditionalAnnotations(Simplifier.Annotation)); 232return root.ReplaceNode(newTarget, newReplacement);
src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)
210var newRoot = root.ReplaceNode(oldArgumentList, GenerateNewArgumentList(oldArgumentList, newArguments));
src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (1)
120var newRoot = root.ReplaceNode(docCommentNode, newDocComment.WithAdditionalAnnotations(Formatter.Annotation));
src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)
115var newRoot = root.ReplaceNode(_classNode, updatedClassNode);
src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)
79rootWithCoreMembers.ReplaceNode( 107var finalRoot = root.ReplaceNode(lastGeneratedMember, lastMemberWithComments);
src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)
107var newRoot = root.ReplaceNode(node, newNode);
src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchStatementCodeFixProvider.cs (1)
50var newRoot = root.ReplaceNode(switchNode, newSwitchNode);
src\Analyzers\Core\CodeFixes\RemoveUnnecessaryParentheses\AbstractRemoveUnnecessaryParenthesesCodeFixProvider.cs (1)
44(_, currentRoot, current) => currentRoot.ReplaceNode(current, syntaxFacts.Unparenthesize(current)),
src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)
54(semanticModel, root, diagnostic, current) => root.ReplaceNode(current, SimplifyConditional(semanticModel, diagnostic, current)),
src\Analyzers\Core\CodeFixes\SimplifyLinqExpression\SimplifyLinqExpressionCodeFixProvider.cs (1)
66return innerInvocationExpression.ReplaceNode(innerName, outerName.WithTriviaFrom(innerName)).WithTrailingTrivia(current.GetTrailingTrivia());
src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)
265var newPropertyTreeRoot = propertyTreeRoot.ReplaceNode(propertyDeclaration, updatedProperty);
src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForAssignment\AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs (1)
150var updatedLocalDeclaration = localDeclaration.ReplaceNode(variable, updatedVariable);
src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)
276return whenPart.ReplaceNode(memberAccess, 287return whenPart.ReplaceNode(elementAccess,
UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)
145var newRoot = root.ReplaceNode(argumentList, newArgumentList);
Microsoft.CodeAnalysis.LanguageServer.Protocol (1)
ExternalAccess\Razor\SimplifyMethodHandler.cs (1)
63var annotatedSyntaxRoot = newTree.GetRoot(cancellationToken).ReplaceNode(node, node.WithAdditionalAnnotations(Simplifier.Annotation));
Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (5)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
Microsoft.CodeAnalysis.PublicApiAnalyzers (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Microsoft.CodeAnalysis.ResxSourceGenerator (1)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
Microsoft.CodeAnalysis.VisualBasic.NetAnalyzers (21)
Microsoft.NetCore.Analyzers\Performance\BasicDoNotGuardCall.Fixer.vb (1)
69Dim newRoot = root.ReplaceNode(conditionalOperationNode, newConditionNode)
Microsoft.NetCore.Analyzers\Performance\BasicPreferDictionaryTryMethodsOverContainsKeyGuardFixer.vb (1)
208WithIfStatement(ifStatement.IfStatement.ReplaceNode(containsKeyInvocation, tryAddInvocation))
Microsoft.NetCore.Analyzers\Performance\BasicPreferHashDataOverComputeHash.Fixer.vb (1)
82root = root.ReplaceNode(root.GetCurrentNode(parent), newParent)
Microsoft.NetCore.Analyzers\Performance\BasicPreferLengthCountIsEmptyOverAnyFixer.vb (8)
29Return root.ReplaceNode(unaryParent, newMemberAccess.WithTriviaFrom(unaryParent)) 38Return root.ReplaceNode(memberAccess, negatedExpression.WithTriviaFrom(memberAccess)) 58Return root.ReplaceNode(unaryParent, newMemberAccess.WithTriviaFrom(unaryParent)) 67Return root.ReplaceNode(invocation, negatedExpression.WithTriviaFrom(invocation)) 90Return root.ReplaceNode(memberAccess.Parent, binaryExpression.WithTriviaFrom(memberAccess.Parent)) 93Return root.ReplaceNode(memberAccess, GetBinaryExpression(memberAccess.Expression, propertyName, SyntaxKind.NotEqualsExpression).WithTriviaFrom(memberAccess)) 107Return root.ReplaceNode(invocation.Parent, binaryExpression.WithTriviaFrom(invocation.Parent)) 110Return root.ReplaceNode(invocation, GetBinaryExpression(expression, propertyName, SyntaxKind.NotEqualsExpression).WithTriviaFrom(invocation))
Microsoft.NetCore.Analyzers\Runtime\BasicSpecifyCultureForToLowerAndToUpper.Fixer.vb (3)
43Dim newRoot = root.ReplaceNode(invocation, newInvocation) 55Dim newRoot = root.ReplaceNode(nodeToReplace, invocation) 64Dim newRoot = root.ReplaceNode(memberAccess, newMemberAccess)
Microsoft.NetCore.Analyzers\Runtime\BasicUseOrdinalStringComparison.Fixer.vb (2)
32Dim newRoot = root.ReplaceNode(memberAccess, newMemberAccess) 54Dim newRoot = root.ReplaceNode(invokeParent, newInvoke)
Microsoft.NetCore.Analyzers\Runtime\BasicUseSpanBasedStringConcat.Fixer.vb (1)
21Return invocationSyntax.ReplaceNode(oldNameSyntax, newNameSyntax)
Microsoft.NetCore.Analyzers\Usage\BasicDoNotCompareSpanToNull.Fixer.vb (1)
39Function(ct) Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(binaryExpression, memberAccess))),
Microsoft.NetCore.Analyzers\Usage\BasicPreferGenericOverloads.Fixer.vb (3)
60.ReplaceNode(castExpressionSyntax, 62.ReplaceNode(invocationContext.Syntax, invocationExpressionSyntax) _ 68.ReplaceNode(invocationContext.Syntax, invocationExpressionSyntax) _
Microsoft.CodeAnalysis.Workspaces (8)
Editing\SyntaxGenerator.cs (3)
1436=> (newDeclaration != null) ? root.ReplaceNode(node, newDeclaration) : RemoveNode(root, node); 1546return root.ReplaceNode(original, combinedTriviaReplacement); 1589var newRoot = root.ReplaceNode(node, trackedFirst);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (1)
VisualStudioMSBuildWorkspaceTests.cs (1)
348var newRoot = root.ReplaceNode(decl, newDecl);
Microsoft.CodeAnalysis.Workspaces.UnitTests (7)
CodeCleanup\CodeCleanupTests.cs (4)
210root = root.ReplaceNode(@class, classWithMember); 231root = root.ReplaceNode(@class, classWithMember); 252root = root.ReplaceNode(@class, classWithMember); 320root = root.ReplaceNode(accessor, newAccessor);
SolutionTests\SolutionTests.cs (2)
3265newSyntaxRoot = syntaxRoot.ReplaceNode(classNode, classNode.WithModifiers([CS.SyntaxFactory.ParseToken("public")])); 3270newSyntaxRoot = syntaxRoot.ReplaceNode(classNode, classNode.WithModifiers(VB.SyntaxFactory.TokenList(VB.SyntaxFactory.ParseToken("Public"))));
SyntaxNodeTests.cs (1)
109trackedRoot = trackedRoot.ReplaceNode(currentClassDecl, classDeclWithField);
Microsoft.Extensions.Logging.Generators (1)
LoggerMessageGenerator.Parser.cs (1)
619typeDeclaration = typeDeclaration.ReplaceNode(parameter, parameter.WithAttributeLists([]));
Microsoft.ML.InternalCodeAnalyzer (3)
ContractsCheckNameofFixProvider.cs (3)
172var newRoot = root.ReplaceNode(nameArg.Expression, nameofExp); 179var newNameofExp = nameofExp.ReplaceNode(nameofExp.ArgumentList.Arguments[0].Expression, exp.WithoutTrivia()); 183var newRoot = root.ReplaceNode(nameArg.Expression, newNameofExp);
Microsoft.VisualStudio.LanguageServices (1)
Venus\ContainedLanguageCodeSupport.cs (1)
223var newRoot = targetSyntaxTree.GetRoot(cancellationToken).ReplaceNode(destinationType, newType);
Microsoft.VisualStudio.LanguageServices.CSharp (7)
CodeModel\CSharpCodeModelService.cs (7)
935typeNode = typeNode.ReplaceNode(member, constructor); 940typeNode = typeNode.ReplaceNode(member, destructor); 2333member = property.ReplaceNode(property.AccessorList, updatedAccessorList); 2373member = property.ReplaceNode(property.AccessorList, updatedAccessorList); 2745return node.ReplaceNode(oldType, newType); 2782newEnumDeclaration = newEnumDeclaration.ReplaceNode(lastMember, lastMember.WithTrailingTrivia(trailingTrivia)); 3241enumDeclaration = enumDeclaration.ReplaceNode(lastMember, lastMember.WithTrailingTrivia(SyntaxTriviaList.Empty));
Microsoft.VisualStudio.LanguageServices.Implementation (2)
CodeModel\AbstractCodeModelService.cs (2)
1080var newRoot = root.ReplaceNode(containerNode, newContainerNode); 1127var newRoot = oldRoot.ReplaceNode(node, annotatedNode);
QuarantineTools.Tests (3)
QuarantineScriptTests.cs (3)
92var newRoot = root.ReplaceNode(method, updated); 144var newRoot = root.ReplaceNode(method, updatedMethod); 244root = root.ReplaceNode(method, updated);
Roslyn.Diagnostics.Analyzers (21)
AbstractApplyTraitToClass`1.cs (1)
119return state.Document.WithSyntaxRoot(syntaxRoot.ReplaceNode(typeDeclaration, newTypeDeclaration));
AbstractCreateTestAccessor`1.cs (1)
97return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(typeDeclaration, newTypeDeclaration));
AbstractExposeMemberForTesting`1.cs (1)
167return document.WithSyntaxRoot(syntaxRoot.ReplaceNode(testAccessorTypeDeclaration, newTypeDeclaration)).Project.Solution;
AbstractRunIterations`1.cs (3)
93updatedMethod = updatedMethod.ReplaceNode( 100updatedMethod = updatedMethod.ReplaceNode( 133return document.WithSyntaxRoot(root.ReplaceNode(method, updatedMethod));
ExportedPartsShouldHaveImportingConstructorCodeFixProvider.cs (3)
138return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)); 155return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)); 205return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration));
ImportingConstructorShouldBeObsoleteCodeFixProvider.cs (5)
114return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)); 135return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)); 160return document.WithSyntaxRoot(root.ReplaceNode(argumentToReplace, descriptionArgument)); 179return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)); 203return document.WithSyntaxRoot(root.ReplaceNode(argumentToReplace, errorArgument));
PartsExportedWithMEFv2MustBeMarkedAsShared.Fixer.cs (1)
65return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration)));
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));
TestExportsShouldNotBeDiscoverableCodeFixProvider.cs (1)
103return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration));
Roslyn.Diagnostics.CSharp.Analyzers (6)
CSharpDoNotUseDebugAssertForInterpolatedStringsFixer.cs (1)
79var newRoot = root.ReplaceNode(debugIdentifierNode, roslynDebugNode);
PreferNullLiteralCodeFixProvider.cs (1)
77return document.WithSyntaxRoot(root.ReplaceNode(syntax, newSyntax));
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)
177var newRoot = root.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationService.cs (2)
555newBlock = block.ReplaceNode(containingStatement, newContainingStatement); 563return destinationMember.ReplaceNode(block, newBlock);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (1)
96return root.ReplaceNode(firstOuterNamespaceWithUsings, newNamespace);
System.Text.RegularExpressions.Generator (3)
UpgradeToGeneratedRegexCodeFixer.cs (3)
145SyntaxNode newTypeDeclarationOrCompilationUnit = typeDeclarationOrCompilationUnit.ReplaceNode(nodeToFix, WithTrivia(replacement, nodeToFix)); 324newTypeDeclarationOrCompilationUnit = newTypeDeclarationOrCompilationUnit.ReplaceNode(oldMember, newMember); 328return document.WithSyntaxRoot(root.ReplaceNode(oldTypeDeclarationOrCompilationUnit, newTypeDeclarationOrCompilationUnit));
System.Windows.Forms.Analyzers.CodeFixes.CSharp (2)
System\Windows\Forms\CSharp\CodeFixes\AddDesignerSerializationVisibility\AddDesignerSerializationVisibilityCodeFixProvider.cs (2)
98root = root.ReplaceNode(propertyDeclarationSyntax, newProperty); 148root.ReplaceNode(
Text.Analyzers (5)
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)
202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)
250var currentRoot = root.ReplaceNode(destinationDeclaration, transformedDeclaration);
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)
245return state.DeclarationStatement.ReplaceNode(
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));