488 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)
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)
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)
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)
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)
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);
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.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)
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)
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)
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,
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.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)
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.VisualBasic (15)
CodeModel\VisualBasicCodeModelService.vb (15)
3012delegateStatement = delegateStatement.ReplaceNode(oldType, newType) 3046eventStatement = eventStatement.ReplaceNode(oldType, newType) 3076eventStatement = eventStatement.ReplaceNode(oldType, newType) 3101newFirstParameter = firstParameter.ReplaceNode(oldType, newType) 3110newAccessorBlock = accessorBlock.ReplaceNode(firstParameter, newFirstParameter) 3124newAccessorBlock = accessorBlock.ReplaceNode(accessorBlock.BlockStatement.ParameterList, newParameterList) 3130eventBlock = eventBlock.ReplaceNode(accessorBlock, newAccessorBlock) 3184declareStatement = declareStatement.ReplaceNode(oldType, newType) 3236methodStatement = methodStatement.ReplaceNode(oldType, newType) 3295parameter = parameter.ReplaceNode(oldType, newType) 3323propertyStatement = propertyStatement.ReplaceNode(oldType, newType) 3365newFirstParameter = firstParameter.ReplaceNode(oldType, newType) 3374newAccessorBlock = accessorBlock.ReplaceNode(firstParameter, newFirstParameter) 3379propertyBlock = propertyBlock.ReplaceNode(accessorBlock, newAccessorBlock) 3406variableDeclarator = variableDeclarator.ReplaceNode(oldType, newType)
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)
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(
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)
219? nodeOrToken.Parent.ReplaceNode(nodeOrToken.AsNode()!, currentNodeOrToken.AsNode()!) 234var newRoot = root.ReplaceNode(nodeOrToken.AsNode()!, currentNode.WithAdditionalAnnotations(marker));