public ConflictResolution( Solution oldSolution, RenamedSpansTracker renamedSpansTracker, string replacementText, bool replacementTextValid) { _oldSolution = oldSolution; _newSolution = oldSolution; _intermediateSolutionContainingOnlyModifiedDocuments = oldSolution; _renamedSpansTracker = renamedSpansTracker; ReplacementText = replacementText; ReplacementTextValid = replacementTextValid; _relatedLocations = new List <RelatedLocation>(); }
// The rename process and annotation for the bookkeeping is performed in one-step private async Task <Solution> AnnotateAndRename_WorkerAsync( Solution originalSolution, Solution partiallyRenamedSolution, HashSet <DocumentId> documentIdsToRename, ISet <RenameLocation> renameLocations, RenamedSpansTracker renameSpansTracker, bool replacementTextValid) { try { foreach (var documentId in documentIdsToRename.ToList()) { _cancellationToken.ThrowIfCancellationRequested(); var document = originalSolution.GetDocument(documentId); var semanticModel = await document.GetSemanticModelAsync(_cancellationToken).ConfigureAwait(false); var originalSyntaxRoot = await semanticModel.SyntaxTree.GetRootAsync(_cancellationToken).ConfigureAwait(false); // Get all rename locations for the current document. var allTextSpansInSingleSourceTree = renameLocations .Where(l => l.DocumentId == documentId && ShouldIncludeLocation(renameLocations, l)) .ToDictionary(l => l.Location.SourceSpan); // All textspan in the document documentId, that requires rename in String or Comment var stringAndCommentTextSpansInSingleSourceTree = renameLocations .Where(l => l.DocumentId == documentId && l.IsRenameInStringOrComment) .GroupBy(l => l.ContainingLocationForStringOrComment) .Select(g => g.Key) .ToSet(); var conflictLocationSpans = _conflictLocations .Where(t => t.DocumentId == documentId) .Select(t => t.ComplexifiedSpan).ToSet(); // Annotate all nodes with a RenameLocation annotations to record old locations & old referenced symbols. // Also annotate nodes that should get complexified (nodes for rename locations + conflict locations) var parameters = new RenameRewriterParameters( _renamedSymbolDeclarationAnnotation, document, semanticModel, originalSyntaxRoot, _replacementText, _originalText, _possibleNameConflicts, allTextSpansInSingleSourceTree, stringAndCommentTextSpansInSingleSourceTree, conflictLocationSpans, originalSolution, _renameLocationSet.Symbol, replacementTextValid, renameSpansTracker, _optionSet, _renameAnnotations, _cancellationToken); var renameRewriterLanguageService = document.GetLanguageService <IRenameRewriterLanguageService>(); var newRoot = renameRewriterLanguageService.AnnotateAndRename(parameters); if (newRoot == originalSyntaxRoot) { // Update the list for the current phase, some files with strings containing the original or replacement // text may have been filtered out. documentIdsToRename.Remove(documentId); } else { partiallyRenamedSolution = partiallyRenamedSolution.WithDocumentSyntaxRoot(documentId, newRoot, PreservationMode.PreserveIdentity); } } return(partiallyRenamedSolution); } catch (Exception e) when(FatalError.ReportUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } }
// The method which performs rename, resolves the conflict locations and returns the result of the rename operation public async Task <ConflictResolution> ResolveConflictsAsync() { try { await FindDocumentsAndPossibleNameConflicts().ConfigureAwait(false); var baseSolution = _renameLocationSet.Solution; // Process rename one project at a time to improve caching and reduce syntax tree serialization. var documentsGroupedByTopologicallySortedProjectId = _documentsIdsToBeCheckedForConflict .GroupBy(d => d.ProjectId) .OrderBy(g => _topologicallySortedProjects.IndexOf(g.Key)); _replacementTextValid = IsIdentifierValid_Worker(baseSolution, _replacementText, documentsGroupedByTopologicallySortedProjectId.Select(g => g.Key), _cancellationToken); var renamedSpansTracker = new RenamedSpansTracker(); var conflictResolution = new ConflictResolution(baseSolution, renamedSpansTracker, _replacementText, _replacementTextValid); foreach (var documentsByProject in documentsGroupedByTopologicallySortedProjectId) { var documentIdsThatGetsAnnotatedAndRenamed = new HashSet <DocumentId>(documentsByProject); using (baseSolution.Services.CacheService?.EnableCaching(documentsByProject.Key)) { // Rename is going to be in 4 phases. // 1st phase - Does a simple token replacement // If the 1st phase results in conflict then we perform then: // 2nd phase is to expand and simplify only the reference locations with conflicts // 3rd phase is to expand and simplify all the conflict locations (both reference and non-reference) // If there are unresolved Conflicts after the 3rd phase then in 4th phase, // We complexify and resolve locations that were resolvable and for the other locations we perform the normal token replacement like the first the phase. for (int phase = 0; phase < 4; phase++) { // Step 1: // The rename process and annotation for the bookkeeping is performed in one-step // The Process in short is, // 1. If renaming a token which is no conflict then replace the token and make a map of the oldspan to the newspan // 2. If we encounter a node that has to be expanded( because there was a conflict in previous phase), we expand it. // If the node happens to contain a token that needs to be renamed then we annotate it and rename it after expansion else just expand and proceed // 3. Through the whole process we maintain a map of the oldspan to newspan. In case of expansion & rename, we map the expanded node and the renamed token conflictResolution.UpdateCurrentSolution(await AnnotateAndRename_WorkerAsync( baseSolution, conflictResolution.NewSolution, documentIdsThatGetsAnnotatedAndRenamed, _renameLocationSet.Locations, renamedSpansTracker, _replacementTextValid).ConfigureAwait(false)); // Step 2: Check for conflicts in the renamed solution bool foundResolvableConflicts = await IdentifyConflictsAsync( documentIdsForConflictResolution : documentIdsThatGetsAnnotatedAndRenamed, allDocumentIdsInProject : documentsByProject, projectId : documentsByProject.Key, conflictResolution : conflictResolution).ConfigureAwait(false); if (!foundResolvableConflicts || phase == 3) { break; } if (phase == 0) { _conflictLocations = conflictResolution.RelatedLocations .Where(loc => (documentIdsThatGetsAnnotatedAndRenamed.Contains(loc.DocumentId) && loc.Type == RelatedLocationType.PossiblyResolvableConflict && loc.IsReference)) .Select(loc => new ConflictLocationInfo(loc)) .ToSet(); // If there were no conflicting locations in references, then the first conflict phase has to be skipped. if (_conflictLocations.Count == 0) { phase++; } } if (phase == 1) { _conflictLocations = _conflictLocations.Concat(conflictResolution.RelatedLocations .Where(loc => documentIdsThatGetsAnnotatedAndRenamed.Contains(loc.DocumentId) && loc.Type == RelatedLocationType.PossiblyResolvableConflict) .Select(loc => new ConflictLocationInfo(loc))) .ToSet(); } // Set the documents with conflicts that need to be processed in the next phase. // Note that we need to get the conflictLocations here since we're going to remove some locations below if phase == 2 documentIdsThatGetsAnnotatedAndRenamed = new HashSet <DocumentId>(_conflictLocations.Select(l => l.DocumentId)); if (phase == 2) { // After phase 2, if there are still conflicts then remove the conflict locations from being expanded var unresolvedLocations = conflictResolution.RelatedLocations .Where(l => (l.Type & RelatedLocationType.UnresolvedConflict) != 0) .Select(l => Tuple.Create(l.ComplexifiedTargetSpan, l.DocumentId)).Distinct(); _conflictLocations = _conflictLocations.Where(l => !unresolvedLocations.Any(c => c.Item2 == l.DocumentId && c.Item1.Contains(l.OriginalIdentifierSpan))).ToSet(); } // Clean up side effects from rename before entering the next phase conflictResolution.ClearDocuments(documentIdsThatGetsAnnotatedAndRenamed); } // Step 3: Simplify the project conflictResolution.UpdateCurrentSolution(await renamedSpansTracker.SimplifyAsync(conflictResolution.NewSolution, documentsByProject, _replacementTextValid, _renameAnnotations, _cancellationToken).ConfigureAwait(false)); await conflictResolution.RemoveAllRenameAnnotationsAsync(documentsByProject, _renameAnnotations, _cancellationToken).ConfigureAwait(false); } } // This rename could break implicit references of this symbol (e.g. rename MoveNext on a collection like type in a // foreach/for each statement ISymbol renamedSymbolInNewSolution = await GetRenamedSymbolInCurrentSolutionAsync(conflictResolution).ConfigureAwait(false); if (IsRenameValid(conflictResolution, renamedSymbolInNewSolution)) { await AddImplicitConflictsAsync( renamedSymbolInNewSolution, _renameLocationSet.Symbol, _renameLocationSet.ImplicitLocations, await conflictResolution.NewSolution.GetDocument(_documentIdOfRenameSymbolDeclaration).GetSemanticModelAsync(_cancellationToken).ConfigureAwait(false), _renameSymbolDeclarationLocation, renamedSpansTracker.GetAdjustedPosition(_renameSymbolDeclarationLocation.SourceSpan.Start, _documentIdOfRenameSymbolDeclaration), conflictResolution, _cancellationToken).ConfigureAwait(false); } foreach (var relatedLocation in conflictResolution.RelatedLocations) { if (relatedLocation.Type == RelatedLocationType.PossiblyResolvableConflict) { relatedLocation.Type = RelatedLocationType.UnresolvedConflict; } } #if DEBUG await DebugVerifyNoErrorsAsync(conflictResolution, _documentsIdsToBeCheckedForConflict).ConfigureAwait(false); #endif return(conflictResolution); } catch (Exception e) when(FatalError.ReportUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } }