ReplaceNode

490 references to ReplaceNode

GenerateDocumentationAndConfigFiles (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));

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)

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)

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)

102return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement))); 131return (currentTarget.Parent, currentTarget.Parent.ReplaceNode(currentTarget, currentReplacement).WithAdditionalAnnotations(Simplifier.Annotation)); 234return 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)

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

187var 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)

184localFunctionWithNewParameters = 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); 250return compilationUnitWithSeparatorLine.ReplaceNode(firstMember, firstMember.WithPrependedLeadingTrivia(orphanedTrivia)); 345return node.ReplaceNode(firstMember, newFirstMember); 379return 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)

107var 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)

282var rootWithUpdatedEventHookupExpression = root.ReplaceNode(eventHookupExpression, updatedEventHookupExpression); 310return 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)

32510var node1 = node0.ReplaceNode(one, decl); 34339syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree; 34553syntaxTree = syntaxTree.GetCompilationUnitRoot().ReplaceNode(rankSpecifierOld, rankSpecifierNew).SyntaxTree;

Microsoft.CodeAnalysis.CSharp.Features (97)

AddImport\CSharpAddImportFeatureService.cs (1)

509return 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)

170var 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)

59annotatedexpressionSyntax = 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)

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

184localFunctionWithNewParameters = 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)

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)

107var 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)

179var updatedParent = parent.ReplaceNode(declaration, updatedDeclaration) 182return 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.Semantic.UnitTests (3)

Semantics\InitOnlyMemberTests.cs (1)

3142var speculatedMethod = accessorDecl.ReplaceNode(accessorDecl.Body, blockStatement);

Semantics\NullableReferenceTypesTests.cs (1)

146500var 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)

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)

187var 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)

4899var 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)

62var 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)

402return 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)

444return root.ReplaceNode(ifNode, updatedIf); 456return root.ReplaceNode(ifNode, updatedIf); 467return root.ReplaceNode(ifNode, updatedIf); 510return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 534return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 560return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 593return root.ReplaceNode(currentParent, updatedParent.WithAdditionalAnnotations(Formatter.Annotation)); 618return 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)

295expandedExtensionInvocation = 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)

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)

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.CodeStyle (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\StatementSyntaxExtensions.vb (1)

125Return methodBlock.ReplaceNode(methodBlock.BlockStatement, newBegin)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

751Return tree.GetRoot().ReplaceNode(oldBlock, newBlock)

Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (6)

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicChangeToYieldCodeFixProvider.vb (1)

48root = root.ReplaceNode(returnStatement, yieldStatement)

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (2)

131Return root.ReplaceNode(methodStatementNode, newFunctionNode) 140Return root.ReplaceNode(lambdaNode.SubOrFunctionHeader, newHeader)

src\Analyzers\VisualBasic\CodeFixes\UseCollectionInitializer\VisualBasicUseCollectionInitializerCodeFixProvider.vb (1)

52Dim newStatement = statement.ReplaceNode(

src\Analyzers\VisualBasic\CodeFixes\UseConditionalExpression\VisualBasicUseConditionalExpressionForAssignmentCodeFixProvider.vb (1)

51Return statement.ReplaceNode(declarator, declarator.WithAdditionalAnnotations(Simplifier.Annotation))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ParameterSyntaxExtensions.vb (1)

21Dim newLambda = oldLambda.ReplaceNode(parameter, newParameterSyntax)

Microsoft.CodeAnalysis.VisualBasic.Features (20)

CodeFixes\CorrectNextControlVariable\CorrectNextControlVariableCodeFixProvider.CodeAction.vb (1)

31Dim updatedRoot = root.ReplaceNode(_node, _newNode)

CodeFixes\GenerateEndConstruct\GenerateEndConstructCodeFixProvider.vb (2)

177updatedProperty = updatedProperty.ReplaceNode(getter, getter.WithEndBlockStatement(SyntaxFactory.EndGetStatement())) 182updatedProperty = updatedProperty.ReplaceNode(setter, setter.WithEndBlockStatement(SyntaxFactory.EndSetStatement()))

CodeFixes\IncorrectFunctionReturnType\IncorrectFunctionReturnTypeCodeFixProvider.vb (1)

82Dim newRoot = root.ReplaceNode(node, rewrittenNode)

EncapsulateField\VisualBasicEncapsulateFieldService.vb (1)

64Return root.ReplaceNode(fieldDeclaration, updatedDeclaration)

ExtractInterface\VisualBasicExtractInterfaceService.vb (3)

141docToRootMap(currentDocId) = currentRoot.ReplaceNode(method, method.WithImplementsClause(GetUpdatedImplementsClause(method.ImplementsClause, qualifiedName))) 147docToRootMap(currentDocId) = currentRoot.ReplaceNode([event], [event].WithImplementsClause(GetUpdatedImplementsClause([event].ImplementsClause, qualifiedName))) 153docToRootMap(currentDocId) = currentRoot.ReplaceNode(prop, prop.WithImplementsClause(GetUpdatedImplementsClause(prop.ImplementsClause, qualifiedName)))

FullyQualify\VisualBasicFullyQualifyService.vb (1)

70Return root.ReplaceNode(simpleName, qualifiedName)

ReplaceConditionalWithStatementsCodeRefactoringProvider\VisualBasicReplaceConditionalWithStatementsCodeRefactoringProvider.vb (1)

66Return localDeclarationStatement.ReplaceNode(

ReplaceMethodWithProperty\VisualBasicReplaceMethodWithPropertyService.vb (1)

208expression.ReplaceNode(name, newName),

ReplacePropertyWithMethods\VisualBasicReplacePropertyWithMethods.ConvertValueToParamRewriter.vb (2)

30Return node.ReplaceNode(node.Name, ConvertToParam(node.Name)) _ 36node.ReplaceNode(node.Name, ConvertToParam(node.Name)),

ReplacePropertyWithMethods\VisualBasicReplacePropertyWithMethods.ConvertValueToReturnsRewriter.vb (2)

27node.ReplaceNode(node.Name, ConvertToReturns(node.Name)), 33node.ReplaceNode(node.Name, ConvertToReturns(node.Name)),

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicChangeToYieldCodeFixProvider.vb (1)

48root = root.ReplaceNode(returnStatement, yieldStatement)

src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (2)

131Return root.ReplaceNode(methodStatementNode, newFunctionNode) 140Return root.ReplaceNode(lambdaNode.SubOrFunctionHeader, newHeader)

src\Analyzers\VisualBasic\CodeFixes\UseCollectionInitializer\VisualBasicUseCollectionInitializerCodeFixProvider.vb (1)

52Dim newStatement = statement.ReplaceNode(

src\Analyzers\VisualBasic\CodeFixes\UseConditionalExpression\VisualBasicUseConditionalExpressionForAssignmentCodeFixProvider.vb (1)

51Return statement.ReplaceNode(declarator, declarator.WithAdditionalAnnotations(Simplifier.Annotation))

Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (3)

Compilation\SemanticModelAPITests.vb (3)

1139Dim speculatedStatement = statement.ReplaceNode(initializer.Value, SyntaxFactory.ParseExpression("0")) 1171Dim speculatedStatement = DirectCast(statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("0")), LocalDeclarationStatementSyntax) 1180Dim newSpeculatedStatement = DirectCast(statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("1.1")), LocalDeclarationStatementSyntax)

Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests (10)

Syntax\SyntaxAnnotationTests.vb (1)

491Return root.ReplaceNode(oldNodeOrToken.AsNode(), newNodeOrToken.AsNode())

TestSyntaxNodes.vb (9)

1249simpleTree = simpleTree.ReplaceNode(firstOper, SyntaxFactory.StringLiteralExpression(SyntaxFactory.StringLiteralToken("""Hi""", "Hi"))) 1253simpleTree = simpleTree.ReplaceNode(firstOper, SyntaxFactory.StringLiteralExpression(SyntaxFactory.StringLiteralToken("""ha""", "ha"))) 1257simpleTree = simpleTree.ReplaceNode(secondOper, SyntaxFactory.StringLiteralExpression(SyntaxFactory.MissingStringLiteral())) 1261simpleTree = simpleTree.ReplaceNode(newSecondOper, SyntaxFactory.StringLiteralExpression(SyntaxFactory.StringLiteralToken("""Bye""", "Bye"))) 1277Dim expr2 = expr.ReplaceNode(bex.Right, SyntaxFactory.ParseExpression("c")) 1906tree = tree.ReplaceNode(op, newOp) 2884Root = Root.ReplaceNode(oldImportClause, newImportsClause) 3309Root = Root.ReplaceNode(Root.Members(1), Module2) 3319Root = Root.ReplaceNode(Root.Members(2), Module3)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (12)

CodeCleanup\AsyncOrIteratorFunctionReturnTypeFixer.vb (1)

204newTypeSyntax = newTypeSyntax.ReplaceNode(currentTypeArgument, newTypeArgument) _

Rename\VisualBasicRenameRewriterLanguageService.vb (2)

190Dim speculativeTree = originalNode.SyntaxTree.GetRoot(_cancellationToken).ReplaceNode(originalNode, newNode) 212speculativeTree = originalNode.SyntaxTree.GetRoot(_cancellationToken).ReplaceNode(originalNode, expandedNewNode)

Simplification\Simplifiers\ExpressionSimplifier.vb (1)

284Dim parentReplacement = parent.ReplaceNode(parent.Expression, replacementNode)

Simplification\Simplifiers\NameSimplifier.vb (1)

339Dim parentReplacement = parent.ReplaceNode(parent.Left, replacementNode)

Simplification\VisualBasicSimplificationService.Expander.vb (1)

533replacement = replacement.ReplaceNode(

Simplification\VisualBasicSimplificationService.vb (3)

138Return originalNode.ReplaceNode(DirectCast(originalNode, AsNewClauseSyntax).NewExpression, DirectCast(reducedNode, EqualsValueSyntax).Value) 144reducedMethod = reducedMethod.ReplaceNode(reducedMethod.BlockStatement, originalMethod.BlockStatement) 145Return reducedMethod.ReplaceNode(reducedMethod.EndBlockStatement, originalMethod.EndBlockStatement)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\StatementSyntaxExtensions.vb (1)

125Return methodBlock.ReplaceNode(methodBlock.BlockStatement, newBegin)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

751Return tree.GetRoot().ReplaceNode(oldBlock, newBlock)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ParameterSyntaxExtensions.vb (1)

21Dim newLambda = oldLambda.ReplaceNode(parameter, newParameterSyntax)

Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (4)

Formatting\FormattingTests.vb (4)

3776root = root.ReplaceNode(implementsStatement, implementsStatement.NormalizeWhitespace(elasticTrivia:=True).WithAdditionalAnnotations(goo)) 3779root = root.ReplaceNode(field, field.NormalizeWhitespace(elasticTrivia:=True).WithAdditionalAnnotations(goo)) 3781root = root.ReplaceNode(prop, prop.NormalizeWhitespace(elasticTrivia:=True).WithAdditionalAnnotations(goo)) 3784root = root.ReplaceNode(method, method.NormalizeWhitespace(elasticTrivia:=True).WithAdditionalAnnotations(goo))

Microsoft.CodeAnalysis.Workspaces (8)

Editing\SyntaxGenerator.cs (3)

1383=> (newDeclaration != null) ? root.ReplaceNode(node, newDeclaration) : RemoveNode(root, node); 1493return root.ReplaceNode(original, combinedTriviaReplacement); 1536var 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)

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.VisualBasic (15)

CodeModel\VisualBasicCodeModelService.vb (15)

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)

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)

187var 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);

Roslyn.Diagnostics.VisualBasic.Analyzers (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

751Return tree.GetRoot().ReplaceNode(oldBlock, newBlock)

System.Text.RegularExpressions.Generator (2)

UpgradeToGeneratedRegexCodeFixer.cs (2)

176newTypeDeclarationOrCompilationUnit = newTypeDeclarationOrCompilationUnit.ReplaceNode(nodeToFix, WithTrivia(replacement, nodeToFix)); 240return document.WithSyntaxRoot(root.ReplaceNode(typeDeclarationOrCompilationUnit, newTypeDeclarationOrCompilationUnit));

System.Windows.Forms.Analyzers.CodeFixes.CSharp (2)

System\Windows\Forms\CSharp\CodeFixes\AddDesignerSerializationVisibility\AddDesignerSerializationVisibilityCodeFixProvider.cs (2)

98root = root.ReplaceNode(propertyDeclarationSyntax, newProperty); 148root.ReplaceNode(

System.Windows.Forms.Analyzers.CodeFixes.VisualBasic (2)

AddDesignerSerializationVisibility\AddDesignerSerializationVisibilityCodeFixProvider.vb (2)

112root = root.ReplaceNode(propertyDeclarationSyntax, newProperty) 164root.ReplaceNode(

Test.Utilities (1)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

202=> semanticRootOfOriginalExpression.ReplaceNode(this.OriginalExpression, annotatedReplacedExpression);

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)