WithSyntaxRoot

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

Authorization\AddAuthorizationBuilderFixer.cs (1)

138return Task.FromResult(document.WithSyntaxRoot(

DetectMismatchedParameterOptionalityFixer.cs (1)

49return document.WithSyntaxRoot(root.ReplaceNode(parameterSyntax, newParam));

Http\HeaderDictionaryAddFixer.cs (2)

74return Task.FromResult(document.WithSyntaxRoot( 103return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(diagnosticTarget, assignment)));

Http\HeaderDictionaryIndexerFixer.cs (1)

60return document.WithSyntaxRoot(root.ReplaceNode(elementAccessExpressionSyntax, newExpression));

RouteParameterUnusedParameterFixer.cs (1)

99return document.WithSyntaxRoot(updatedSyntaxTree);

WebApplicationBuilderFixer.cs (1)

81return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(diagnosticTarget, invocation)));

ComponentParametersShouldBePublicCodeFixProvider.cs (1)

57return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot));

Verifiers\CodeFixVerifier.cs (1)

109document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));

ComponentParametersShouldBePublicCodeFixProvider.cs (1)

57return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot));

Verifiers\CodeFixVerifier.cs (1)

109document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));

AddResponseTypeAttributeCodeFixAction.cs (1)

124return document.WithSyntaxRoot(root);

MetaAnalyzers\Fixers\ApplyDiagnosticAnalyzerAttributeFix.cs (1)

78return Task.FromResult(document.WithSyntaxRoot(newRoot));

MetaAnalyzers\Fixers\ConfigureGeneratedCodeAnalysisFix.cs (1)

84return document.WithSyntaxRoot(root.ReplaceNode(methodDeclaration, newMethodDeclaration));

MetaAnalyzers\Fixers\DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs (1)

168return document.WithSyntaxRoot(newRoot).Project.Solution;

MetaAnalyzers\Fixers\EnableConcurrentExecutionFix.cs (1)

69return document.WithSyntaxRoot(root.ReplaceNode(methodDeclaration, newMethodDeclaration));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

103return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement)));

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

64return Task.FromResult(document.WithSyntaxRoot(newRoot));

src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

64token => Task.FromResult(otherDocument.WithSyntaxRoot(newRoot)),

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (1)

121return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractRemoveDocCommentNodeCodeFixProvider.cs (1)

82return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\FileHeaders\AbstractFileHeaderCodeFixProvider.cs (1)

46=> document.WithSyntaxRoot(await GetTransformedSyntaxRootAsync(document, cancellationToken).ConfigureAwait(false));

src\Analyzers\Core\CodeFixes\Formatting\FormattingCodeFixProvider.cs (1)

85return context.Document.WithSyntaxRoot(formattedRoot);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateLocalCodeAction.cs (1)

39var newDocument = _document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

117return _document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)

78var docWithAllMembers = docWithCoreMembers.WithSyntaxRoot( 108return document.WithSyntaxRoot(finalRoot);

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (1)

196var newDocument = document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)

109var newDocument = document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\NewLines\ConsecutiveStatementPlacement\ConsecutiveStatementPlacementCodeFixProvider.cs (1)

57return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\NewLines\MultipleBlankLines\AbstractMultipleBlankLinesCodeFixProvider.cs (1)

60return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (4)

281return document.WithSyntaxRoot(root); 783var newDocument = document.WithSyntaxRoot(currentRoot); 851document = document.WithSyntaxRoot(rootWithTrackedNodes); 905document = document.WithSyntaxRoot(rootWithRemovedDeclaration);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

src\Analyzers\CSharp\CodeFixes\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)

121return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (2)

44var updatedDocument = document.WithSyntaxRoot(updatedRoot); 246var updatedDocument = document.WithSyntaxRoot(updatedRoot);

src\Analyzers\CSharp\CodeFixes\HideBase\HideBaseCodeFixProvider.AddNewKeywordAction.cs (1)

28return document.WithSyntaxRoot(root.ReplaceNode(node, GetNewNode(node, modifierOrder)));

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)

84_ => Task.FromResult(document.WithSyntaxRoot(root)),

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)

35return document.WithSyntaxRoot(syntaxEditor.GetChangedRoot());

src\Analyzers\CSharp\CodeFixes\MakeRefStruct\MakeRefStructCodeFixProvider.cs (1)

76return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (1)

158var newDocument = document.WithSyntaxRoot(newCompilationUnitWithHeader);

src\Analyzers\CSharp\CodeFixes\NewLines\ConsecutiveBracePlacement\ConsecutiveBracePlacementCodeFixProvider.cs (1)

58return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementCodeFixProvider.cs (1)

85return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs (1)

58return document.WithSyntaxRoot(editor.GetChangedRoot());

src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)

93return document.WithSyntaxRoot(editor.GetChangedRoot());

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\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)

73return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

127var newDocument = document.WithSyntaxRoot(newRoot.ReplaceNode(creationExpression, dummyObjectCreation));

src\Analyzers\CSharp\CodeFixes\UseExplicitTypeForConst\UseExplicitTypeForConstCodeFixProvider.cs (1)

68return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

74return document.WithSyntaxRoot(formattedRoot);

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (2)

213documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken).ConfigureAwait(false); 283return documentWithNameAdded.WithSyntaxRoot(rootWithUpdatedEventHookupExpression);

CodeGeneration\SyntaxGeneratorTests.cs (1)

46var newDocument = document.WithSyntaxRoot(newRoot);

Diagnostics\FixAllProvider\BatchFixerTests.cs (1)

84var newDocument = context.Document.WithSyntaxRoot(newRoot);

Formatting\CodeCleanupTests.TestFixers.cs (3)

40return context.Document.WithSyntaxRoot(newRoot); 109document = document.WithSyntaxRoot(newRoot); 165document = document.WithSyntaxRoot(newRoot);

AddImport\CSharpAddImportFeatureService.cs (2)

350return document.WithSyntaxRoot(newRoot); 404return document.WithSyntaxRoot(newRoot);

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (2)

226document = document.WithSyntaxRoot(editor.GetChangedRoot()); 252return document.WithSyntaxRoot(editor.GetChangedRoot());

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

126return document.WithSyntaxRoot(newRoot);

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (3)

68_ => Task.FromResult(document.WithSyntaxRoot(replacementFunc(root))), 598document = document.WithSyntaxRoot(editor.OriginalRoot.TrackNodes(nodes)); 617document = document.WithSyntaxRoot(replacementFunc(root));

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

172return document.WithSyntaxRoot(finalRoot);

ConvertBetweenRegularAndVerbatimString\AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (1)

91return document.WithSyntaxRoot(root.ReplaceNode(stringExpression, newStringExpression));

ConvertProgram\ConvertProgramTransform_ProgramMain.cs (1)

56return document.WithSyntaxRoot(newRoot);

ConvertProgram\ConvertProgramTransform_TopLevelStatements.cs (2)

45return document.WithSyntaxRoot(rootWithGlobalStatements); 81var documentWithImportsAdded = document.WithSyntaxRoot(addImportsService.AddImports(

ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (1)

208return document.WithSyntaxRoot(newRoot);

ConvertToExtension\ConvertToExtensionFixAllProvider.cs (1)

56return document.WithSyntaxRoot(newRoot);

ConvertToRawString\ConvertStringToRawStringCodeRefactoringProvider.cs (1)

139return document.WithSyntaxRoot(root.ReplaceNode(expression, replacement));

DecompiledSource\CSharpDecompiledSourceService.cs (2)

95return document.WithSyntaxRoot(newRoot); 104return document.WithSyntaxRoot(newSyntaxRoot);

EncapsulateField\CSharpEncapsulateFieldService.cs (2)

63document = document.WithSyntaxRoot(root); 84document = document.WithSyntaxRoot(root);

ExtractMethod\CSharpMethodExtractor.cs (1)

201document = document.WithSyntaxRoot(root.ReplaceNode(originalMethodDefinition, methodDefinition));

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (1)

1128return originalDocument.Document.WithSyntaxRoot(newRoot);

ExtractMethod\CSharpSelectionResult.cs (1)

38var newDocument = await SemanticDocument.CreateAsync(document.Document.WithSyntaxRoot(AddAnnotations(

Formatting\CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs (1)

75return document.WithSyntaxRoot(editor.GetChangedRoot());

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider_Update.cs (1)

40var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution;

IntroduceVariable\CSharpIntroduceVariableService_IntroduceField.cs (2)

64return Task.FromResult(document.Document.WithSyntaxRoot(newRoot)); 77return Task.FromResult(document.Document.WithSyntaxRoot(newRoot));

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (4)

133return document.Document.WithSyntaxRoot( 262return document.Document.WithSyntaxRoot(newRoot); 352return document.Document.WithSyntaxRoot(editor.GetChangedRoot()); 421return document.Document.WithSyntaxRoot(newRoot);

IntroduceVariable\CSharpIntroduceVariableService_IntroduceQueryLocal.cs (2)

72return document.Document.WithSyntaxRoot(newRoot); 91return document.Document.WithSyntaxRoot(newRoot);

MetadataAsSource\CSharpMetadataAsSourceService.cs (3)

55return document.WithSyntaxRoot(newRoot); 67return document.WithSyntaxRoot(newSyntaxRoot); 121return document.WithSyntaxRoot(newRoot);

Organizing\CSharpOrganizingService.cs (1)

29return document.WithSyntaxRoot(rewriter.Visit(root));

ReverseForStatement\CSharpReverseForStatementCodeRefactoringProvider.cs (1)

303return document.WithSyntaxRoot(editor.GetChangedRoot());

Snippets\AbstractCSharpTypeSnippetProvider.cs (1)

107return document.WithSyntaxRoot(newRoot);

Snippets\CSharpIntMainSnippetProvider.cs (1)

63return document.WithSyntaxRoot(updatedRoot);

Snippets\CSharpSnippetHelpers.cs (1)

59return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs (1)

121return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (2)

44var updatedDocument = document.WithSyntaxRoot(updatedRoot); 246var updatedDocument = document.WithSyntaxRoot(updatedRoot);

src\Analyzers\CSharp\CodeFixes\HideBase\HideBaseCodeFixProvider.AddNewKeywordAction.cs (1)

28return document.WithSyntaxRoot(root.ReplaceNode(node, GetNewNode(node, modifierOrder)));

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)

84_ => Task.FromResult(document.WithSyntaxRoot(root)),

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)

35return document.WithSyntaxRoot(syntaxEditor.GetChangedRoot());

src\Analyzers\CSharp\CodeFixes\MakeRefStruct\MakeRefStructCodeFixProvider.cs (1)

76return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (1)

158var newDocument = document.WithSyntaxRoot(newCompilationUnitWithHeader);

src\Analyzers\CSharp\CodeFixes\NewLines\ConsecutiveBracePlacement\ConsecutiveBracePlacementCodeFixProvider.cs (1)

58return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementCodeFixProvider.cs (1)

85return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs (1)

58return document.WithSyntaxRoot(editor.GetChangedRoot());

src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)

93return document.WithSyntaxRoot(editor.GetChangedRoot());

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\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (1)

73return document.WithSyntaxRoot(newRoot);

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

127var newDocument = document.WithSyntaxRoot(newRoot.ReplaceNode(creationExpression, dummyObjectCreation));

src\Analyzers\CSharp\CodeFixes\UseExplicitTypeForConst\UseExplicitTypeForConstCodeFixProvider.cs (1)

68return document.WithSyntaxRoot(newRoot);

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

166return document.WithSyntaxRoot(newRoot); 248document = document.WithSyntaxRoot(currentRoot);

UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeRefactoringProvider.cs (1)

203return document.WithSyntaxRoot(newRoot);

OrganizeImports\CSharpOrganizeImportsService.cs (1)

28return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

74return document.WithSyntaxRoot(formattedRoot);

CodeGeneration\AddImportsTests.cs (1)

55doc = doc.WithSyntaxRoot(root);

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCommitter.cs (1)

192var documentWithOriginalName = document.WithSyntaxRoot(syntaxTreeWithOriginalName.GetRoot(cancellationToken));

CodeGeneration\AbstractCodeGenerationTests.cs (1)

39var annotatedDocument = document.WithSyntaxRoot(

CodeGeneration\CodeGenerationTests.cs (6)

94testContext.Result = testContext.Document.WithSyntaxRoot(newRoot); 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));

CodeFixes\CodeFixServiceTests.vb (2)

229context.RegisterCodeFix(CodeAction.Create("FIX_TEST0000", Function(ct) Task.FromResult(context.Document.WithSyntaxRoot(root))), context.Diagnostics) 254context.RegisterCodeFix(CodeAction.Create("FIX_TEST1111", Function(ct) Task.FromResult(context.Document.WithSyntaxRoot(root))), context.Diagnostics)

Simplification\ParameterSimplificationTests.vb (1)

26Dim annotatedDocument = document.WithSyntaxRoot(

AddPackage\AspNetCoreAddPackageCodeAction.cs (1)

89var updatedDocument = document.WithSyntaxRoot(newRoot);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (1)

68return Task.FromResult<Solution?>(constructorDocument.WithSyntaxRoot(newRoot).Project.Solution);

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

176return document.WithSyntaxRoot(editor.GetChangedRoot());

AddFileBanner\AbstractAddFileBannerNewDocumentFormattingProvider.cs (2)

39return document.WithSyntaxRoot(rootWithFileHeader); 49return document.WithSyntaxRoot(rootWithBanner);

AddFileBanner\AddFileBannerHelpers.cs (1)

41return destinationDocument.WithSyntaxRoot(newRoot);

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (1)

71var updatedDocument = newDocument.WithSyntaxRoot(updatedRoot);

AddImport\References\Reference.cs (1)

93var newDocument = document.WithSyntaxRoot(root);

ChangeSignature\AbstractChangeSignatureService.cs (1)

423var updatedDoc = currentSolution.GetRequiredDocument(docId).WithSyntaxRoot(updatedRoots[docId]);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs (1)

33return suppressionsDoc.WithSyntaxRoot(suppressionsRoot);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (1)

147var result = suppressionsDoc.WithSyntaxRoot(suppressionsRoot);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.LocalSuppressMessageCodeAction.cs (1)

34return _document.WithSyntaxRoot(newRoot);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaHelpers.cs (2)

62return document.WithSyntaxRoot(newRoot); 267document = document.WithSyntaxRoot(root);

CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs (1)

137return document.WithSyntaxRoot(finalRoot);

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)

635var formattedDocument = documentWithAddedImports.WithSyntaxRoot(root); 885document = document.WithSyntaxRoot(root);

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (2)

101document = document.WithSyntaxRoot(annotatedRoot).WithFrozenPartialSemantics(forceFreeze: true, cancellationToken); 222var document = memberContainingDocument.WithSyntaxRoot(root);

Completion\Providers\ImportCompletionProvider\ImportCompletionProviderHelpers.cs (1)

44var documentWithImport = document.WithSyntaxRoot(rootWithImport);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (1)

140var updatedDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

ConvertAnonymousType\AbstractConvertAnonymousTypeToTupleCodeRefactoringProvider.cs (1)

121return document.WithSyntaxRoot(editor.GetChangedRoot());

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

126return document.WithSyntaxRoot(newRoot);

ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)

77return document.WithSyntaxRoot(newRoot);

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

425return document.WithSyntaxRoot(newRoot);

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

382return document.WithSyntaxRoot(editor.GetChangedRoot());

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (1)

200document = document.WithSyntaxRoot(editor.OriginalRoot.TrackNodes(ifStatements));

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

55return document.WithSyntaxRoot(root);

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

49c => Task.FromResult(document.WithSyntaxRoot(documentUpdateInfo.UpdateRoot(root))),

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (1)

155return Task.FromResult(document.WithSyntaxRoot(rootWithLinqUsing));

ConvertNumericLiteral\AbstractConvertNumericLiteralCodeRefactoringProvider.cs (1)

128return Task.FromResult(document.WithSyntaxRoot(updatedRoot));

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

124return document.WithSyntaxRoot(root.ReplaceNode(top, interpolatedString));

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

310return document.WithSyntaxRoot(editor.GetChangedRoot());

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

110return Task.FromResult(document.WithSyntaxRoot(

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

259return document.WithSyntaxRoot(newRoot).Project.Solution;

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

179document = document.WithSyntaxRoot(fieldDeclaration.SyntaxTree.GetRoot(cancellationToken).ReplaceNode(fieldDeclaration.GetSyntax(cancellationToken), 202document = await Formatter.FormatAsync(document.WithSyntaxRoot(rewrittenFieldDeclaration), Formatter.Annotation, formattingOptions, cancellationToken).ConfigureAwait(false);

ExtractClass\ExtractClassWithDialogCodeAction.cs (1)

255unformattedSolution = document.WithSyntaxRoot(currentRoot).Project.Solution;

ExtractInterface\AbstractExtractInterfaceService.cs (1)

345unformattedSolution = document.WithSyntaxRoot(editor.GetChangedRoot()).Project.Solution;

ExtractMethod\MethodExtractor.cs (2)

150var annotatedDocument = document.WithSyntaxRoot(root); 157var formattedDocument = simplifiedDocument.WithSyntaxRoot(

FullyQualify\AbstractFullyQualifyService.cs (1)

221var newDocument = document.WithSyntaxRoot(newRoot);

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

307return document.WithSyntaxRoot(newRoot);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)

118var newDocument = _document.WithSyntaxRoot(oldRoot.ReplaceNode(oldType, newType));

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (3)

627return document.WithSyntaxRoot(newRoot); 688return document.WithSyntaxRoot(newRoot); 929return document.WithSyntaxRoot(newRoot);

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (2)

377var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 525var documentWithMemberAdded = document.WithSyntaxRoot(editor.GetChangedRoot());

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (5)

179return document.WithSyntaxRoot(root.ReplaceNode( 193return document.WithSyntaxRoot(root.ReplaceNode(declarationStatement, usingDeclarationStatement)); 226return document.WithSyntaxRoot(newRoot); 259return document.WithSyntaxRoot(root.ReplaceNode( 268return document.WithSyntaxRoot(root.ReplaceNode(

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (1)

105return document.WithSyntaxRoot(newRoot);

IntroduceVariable\AbstractIntroduceVariableService.cs (2)

426var newDocument = semanticDocument.Document.WithSyntaxRoot(newRoot); 456newDocument = newSemanticDocument.Document.WithSyntaxRoot(newRoot);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

58return document.WithSyntaxRoot(editor.GetChangedRoot());

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

300return document.WithSyntaxRoot(

InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (2)

108return document.WithSyntaxRoot(root.ReplaceNode( 134return document.WithSyntaxRoot(root.ReplaceNode(

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

85var sourceDoc = _document.WithSyntaxRoot(root);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

88return document.WithSyntaxRoot(newRoot);

OrganizeImports\OrganizeImportsCodeRefactoringProvider.cs (1)

91cancellationToken => Task.FromResult(document.WithSyntaxRoot(newRoot))),

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

215return document.WithSyntaxRoot(newRoot); 257return document.WithSyntaxRoot(newRoot);

Shared\Extensions\DocumentExtensions.cs (2)

39return document.WithSyntaxRoot(newRoot); 49return document.WithSyntaxRoot(newRoot);

Shared\Utilities\AnnotatedSymbolMapping.cs (1)

101annotatedSolution = document.WithSyntaxRoot(root.Value).Project.Solution;

Shared\Utilities\ExtractTypeHelpers.cs (2)

46var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot()); 107newTypeDocument = newTypeDocument.WithSyntaxRoot(annotatedRoot);

Snippets\SnippetFunctionService.cs (1)

154var documentWithAnnotations = documentWithFullyQualifiedTypeName.WithSyntaxRoot(updatedRoot);

Snippets\SnippetProviders\AbstractSnippetProvider.cs (3)

96var annotatedReformattedDocument = documentWithIndentation.WithSyntaxRoot(reformattedRoot); 185return snippetDocument.WithSyntaxRoot(root); 201document = document.WithSyntaxRoot(annotatedSnippetRoot);

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

225return document.WithSyntaxRoot(newRoot);

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (1)

77return document.WithSyntaxRoot(newRoot);

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (1)

75return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

103return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement)));

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

64return Task.FromResult(document.WithSyntaxRoot(newRoot));

src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

64token => Task.FromResult(otherDocument.WithSyntaxRoot(newRoot)),

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractAddDocCommentNodesCodeFixProvider.cs (1)

121return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractRemoveDocCommentNodeCodeFixProvider.cs (1)

82return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\FileHeaders\AbstractFileHeaderCodeFixProvider.cs (1)

46=> document.WithSyntaxRoot(await GetTransformedSyntaxRootAsync(document, cancellationToken).ConfigureAwait(false));

src\Analyzers\Core\CodeFixes\Formatting\FormattingCodeFixProvider.cs (1)

85return context.Document.WithSyntaxRoot(formattedRoot);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateLocalCodeAction.cs (1)

39var newDocument = _document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

117return _document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)

78var docWithAllMembers = docWithCoreMembers.WithSyntaxRoot( 108return document.WithSyntaxRoot(finalRoot);

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (1)

196var newDocument = document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)

109var newDocument = document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\NewLines\ConsecutiveStatementPlacement\ConsecutiveStatementPlacementCodeFixProvider.cs (1)

57return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\NewLines\MultipleBlankLines\AbstractMultipleBlankLinesCodeFixProvider.cs (1)

60return document.WithSyntaxRoot(newRoot);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (4)

281return document.WithSyntaxRoot(root); 783var newDocument = document.WithSyntaxRoot(currentRoot); 851document = document.WithSyntaxRoot(rootWithTrackedNodes); 905document = document.WithSyntaxRoot(rootWithRemovedDeclaration);

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (3)

263var updatedFieldDocument = fieldDocument.WithSyntaxRoot(editor.GetChangedRoot()); 278var updatedFieldDocument = fieldDocument.WithSyntaxRoot(newFieldTreeRoot); 279var updatedPropertyDocument = propertyDocument.WithSyntaxRoot(newPropertyTreeRoot);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

146return Task.FromResult(document.WithSyntaxRoot(newRoot));

Wrapping\AbstractCodeActionComputer.cs (1)

166var newDocument = OriginalDocument.WithSyntaxRoot(rewrittenRoot);

ExternalAccess\Razor\SimplifyMethodHandler.cs (1)

64var annotatedDocument = originalDocument.WithSyntaxRoot(annotatedSyntaxRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

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

53Function(c) Task.FromResult(document.WithSyntaxRoot(root)),

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

99Return CodeAction.Create(title, Function(c) Task.FromResult(document.WithSyntaxRoot(root)), title) 107Return CodeAction.Create(title, Function(c) Task.FromResult(document.WithSyntaxRoot(root)), title)

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (1)

79Dim trackedDocument = document.WithSyntaxRoot(trackedRoot)

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

32Return _document.WithSyntaxRoot(updatedRoot)

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.AddKeywordCodeAction.vb (1)

43Return _document.WithSyntaxRoot(updatedRoot)

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.ReplaceKeywordCodeAction.vb (1)

42Return _document.WithSyntaxRoot(updatedRoot)

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.ReplaceTokenKeywordCodeAction.vb (1)

35Return _document.WithSyntaxRoot(rootWithoutToken)

CodeFixes\IncorrectFunctionReturnType\IncorrectFunctionReturnTypeCodeFixProvider.vb (1)

83Dim newDocument = document.WithSyntaxRoot(newRoot)

CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.AddKeywordAction.vb (1)

48Return _document.WithSyntaxRoot(newRoot)

CodeRefactorings\RemoveStatementCodeAction.vb (1)

32Return _document.WithSyntaxRoot(updatedRoot)

MetadataAsSource\VisualBasicMetadataAsSourceService.vb (2)

50Return document.WithSyntaxRoot(newRoot) 63Return document.WithSyntaxRoot(newSyntaxRoot)

Organizing\VisualBasicOrganizerService.vb (1)

25Return document.WithSyntaxRoot(rewriter.Visit(root))

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

53Function(c) Task.FromResult(document.WithSyntaxRoot(root)),

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

99Return CodeAction.Create(title, Function(c) Task.FromResult(document.WithSyntaxRoot(root)), title) 107Return CodeAction.Create(title, Function(c) Task.FromResult(document.WithSyntaxRoot(root)), title)

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (1)

79Dim trackedDocument = document.WithSyntaxRoot(trackedRoot)

CodeCleanup\Providers\AbstractTokensCodeCleanupProvider.vb (1)

27Return If(root Is newRoot, document, document.WithSyntaxRoot(newRoot))

OrganizeImports\VisualBasicOrganizeImportsService.vb (1)

24Return document.WithSyntaxRoot(newRoot)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicRemoveUnnecessaryImportsService.vb (1)

47Return document.WithSyntaxRoot(newRoot)

CodeGeneration\AddImportsTests.vb (1)

60doc = doc.WithSyntaxRoot(root)

CaseCorrection\AbstractCaseCorrectionService.cs (1)

38return (root == newRoot) ? document : document.WithSyntaxRoot(newRoot);

CodeCleanup\AbstractCodeCleanerService.cs (1)

63var annotatedDocument = document.WithSyntaxRoot(annotatedRoot);

CodeCleanup\Providers\FormatCodeCleanupProvider.cs (1)

29: document.WithSyntaxRoot(result.GetFormattedRoot(cancellationToken));

CodeRefactorings\SyntaxEditorBasedCodeRefactoringProvider.cs (1)

76return document.WithSyntaxRoot(newRoot);

Editing\DocumentEditor.cs (1)

54=> OriginalDocument.WithSyntaxRoot(this.GetChangedRoot());

Editing\SolutionEditor.cs (1)

49var newDoc = currentDoc.WithSyntaxRoot(docEd.GetChangedRoot());

Formatting\Formatter.cs (3)

96return document.WithSyntaxRoot(Format(root, spans, services, options, rules, cancellationToken)); 117return document.WithSyntaxRoot(Format(root, annotation, services, options, rules, cancellationToken)); 139return document.WithSyntaxRoot(Format(root, annotation, services, formattingOptions, rules, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

Workspace\Solution\SourceGeneratedDocument.cs (1)

34=> (SourceGeneratedDocument)base.WithSyntaxRoot(root);

VisualStudioMSBuildWorkspaceTests.cs (3)

349var newDoc = d1.WithSyntaxRoot(newRoot); 2872var doc2 = document.WithSyntaxRoot(gen.CompilationUnit()); // empty CU 2886var doc3 = document.WithSyntaxRoot(gen.CompilationUnit()); // empty CU

BatchFixAllProviderTests.cs (1)

118return document.WithSyntaxRoot(root.ReplaceToken(token, newToken));

CodeCleanup\CodeCleanupTests.cs (8)

145document = document.WithSyntaxRoot((await document.GetSyntaxRootAsync()).WithAdditionalAnnotations(annotation)); 160document = document.WithSyntaxRoot((await document.GetSyntaxRootAsync()).WithAdditionalAnnotations(annotation)); 193return document.WithSyntaxRoot(root); 214return document.WithSyntaxRoot(root); 235return document.WithSyntaxRoot(root); 256return document.WithSyntaxRoot(root); 321document = document.WithSyntaxRoot(root); 365return document.WithSyntaxRoot(root);

SolutionTests\SolutionTests.cs (2)

3273var documentWithAttribute = document.WithSyntaxRoot(newSyntaxRoot); 4039var newDoc = doc.WithSyntaxRoot(newRoot);

SyntaxNodeTests.cs (1)

112doc = doc.WithSyntaxRoot(trackedRoot);

WorkspaceTests\AdhocWorkspaceTests.cs (1)

347var newDoc = doc.WithSyntaxRoot(newRoot);

ContractsCheckNameofFixProvider.cs (2)

173return document.WithSyntaxRoot(newRoot); 184return document.WithSyntaxRoot(newRoot);

Venus\ContainedLanguageCodeSupport.cs (1)

226targetDocument.WithSyntaxRoot(newRoot), Simplifier.Annotation, options.CleanupOptions.SimplifierOptions, cancellationToken).WaitAndGetResult_Venus(cancellationToken).GetSyntaxRootSynchronously(cancellationToken);

Snippets\CSharpSnippetExpansionLanguageHelper.cs (1)

99var newDocument = document.WithSyntaxRoot(newRoot);

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 (1)

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\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);

TestExportsShouldNotBeDiscoverableCodeFixProvider.cs (1)

103return document.WithSyntaxRoot(root.ReplaceNode(declaration, newDeclaration));

CSharpDoNotUseDebugAssertForInterpolatedStringsFixer.cs (1)

80return document.WithSyntaxRoot(newRoot);

PreferNullLiteralCodeFixProvider.cs (1)

77return document.WithSyntaxRoot(root.ReplaceNode(syntax, newSyntax));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

74return document.WithSyntaxRoot(formattedRoot);

UpgradeToGeneratedRegexCodeFixer.cs (1)

240return document.WithSyntaxRoot(root.ReplaceNode(typeDeclarationOrCompilationUnit, newTypeDeclarationOrCompilationUnit));

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

105document = document.WithSyntaxRoot(root); 147document = document.WithSyntaxRoot(

AddDesignerSerializationVisibility\AddDesignerSerializationVisibilityCodeFixProvider.vb (2)

119document = document.WithSyntaxRoot(root) 163document = document.WithSyntaxRoot(

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

76document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodes.Select(static t => t.diagnosticNode))),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

89return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService.cs (1)

252var newDocument = oldDocument.WithSyntaxRoot(currentRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (2)

167return document.WithSyntaxRoot(root); 250return document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (2)

171document = document.WithSyntaxRoot(originalRoot.TrackNodes(originalNodePairs.SelectMany(pair => pair.nodes.additionalNodes.Concat(pair.nodes.semanticNode)))); 185document = document.WithSyntaxRoot(replacementRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

127var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

115return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (4)

106document = document.WithSyntaxRoot(root); 134document = document.WithSyntaxRoot(root); 235var newDocument = document.WithSyntaxRoot(newRoot); 304return document.WithSyntaxRoot(newRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SemanticDocument.cs (1)

28var newDocument = this.Document.WithSyntaxRoot(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

37var newDocument = this.Document.WithSyntaxRoot(root);