internal async Task RemoveAllRenameAnnotationsAsync(IEnumerable<DocumentId> documentWithRenameAnnotations, AnnotationTable<RenameAnnotation> annotationSet, CancellationToken cancellationToken) { foreach (var documentId in documentWithRenameAnnotations) { if (_renamedSpansTracker.IsDocumentChanged(documentId)) { var document = _newSolution.GetDocument(documentId); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // For the computeReplacementToken and computeReplacementNode functions, use // the "updated" node to maintain any annotation removals from descendants. var newRoot = root.ReplaceSyntax( nodes: annotationSet.GetAnnotatedNodes(root), computeReplacementNode: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()), tokens: annotationSet.GetAnnotatedTokens(root), computeReplacementToken: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()), trivia: SpecializedCollections.EmptyEnumerable<SyntaxTrivia>(), computeReplacementTrivia: null); _intermediateSolutionContainingOnlyModifiedDocuments = _intermediateSolutionContainingOnlyModifiedDocuments.WithDocumentSyntaxRoot(documentId, newRoot, PreservationMode.PreserveIdentity); } } _newSolution = _intermediateSolutionContainingOnlyModifiedDocuments; }
public Session( RenameLocations renameLocationSet, Location renameSymbolDeclarationLocation, string originalText, string replacementText, OptionSet optionSet, Func<IEnumerable<ISymbol>, bool?> newSymbolsAreValid, CancellationToken cancellationToken) { _renameLocationSet = renameLocationSet; _renameSymbolDeclarationLocation = renameSymbolDeclarationLocation; _originalText = originalText; _replacementText = replacementText; _optionSet = optionSet; _hasConflictCallback = newSymbolsAreValid; _cancellationToken = cancellationToken; _renamedSymbolDeclarationAnnotation = new RenameAnnotation(); _conflictLocations = SpecializedCollections.EmptySet<ConflictLocationInfo>(); _replacementTextValid = true; _possibleNameConflicts = new List<string>(); // only process documents which possibly contain the identifiers. _documentsIdsToBeCheckedForConflict = new HashSet<DocumentId>(); _documentIdOfRenameSymbolDeclaration = renameLocationSet.Solution.GetDocument(renameSymbolDeclarationLocation.SourceTree).Id; _renameAnnotations = new AnnotationTable<RenameAnnotation>(RenameAnnotation.Kind); }
public Session(RenameLocationSet renameLocationSet, Location renameSymbolDeclarationLocation, string originalText, string replacementText, OptionSet optionSet, CancellationToken cancellationToken) { this.renameLocationSet = renameLocationSet; this.renameSymbolDeclarationLocation = renameSymbolDeclarationLocation; this.originalText = originalText; this.replacementText = replacementText; this.optionSet = optionSet; this.cancellationToken = cancellationToken; this.renamedSymbolDeclarationAnnotation = new RenameAnnotation(); this.conflictLocations = SpecializedCollections.EmptySet<ConflictLocationInfo>(); this.replacementTextValid = true; this.possibleNameConflicts = new List<string>(); // only process documents which possibly contain the identifiers. this.documentsIdsToBeCheckedForConflict = new HashSet<DocumentId>(); this.documentIdOfRenameSymbolDeclaration = renameLocationSet.Solution.GetDocument(renameSymbolDeclarationLocation.SourceTree).Id; this.renameAnnotations = new AnnotationTable<RenameAnnotation>(RenameAnnotation.Kind); }
public Session(RenameLocationSet renameLocationSet, Location renameSymbolDeclarationLocation, string originalText, string replacementText, OptionSet optionSet, CancellationToken cancellationToken) { _renameLocationSet = renameLocationSet; _renameSymbolDeclarationLocation = renameSymbolDeclarationLocation; _originalText = originalText; _replacementText = replacementText; _optionSet = optionSet; _cancellationToken = cancellationToken; _renamedSymbolDeclarationAnnotation = new RenameAnnotation(); _conflictLocations = SpecializedCollections.EmptySet <ConflictLocationInfo>(); _replacementTextValid = true; _possibleNameConflicts = new List <string>(); // only process documents which possibly contain the identifiers. _documentsIdsToBeCheckedForConflict = new HashSet <DocumentId>(); _documentIdOfRenameSymbolDeclaration = renameLocationSet.Solution.GetDocument(renameSymbolDeclarationLocation.SourceTree).Id; _renameAnnotations = new AnnotationTable <RenameAnnotation>(RenameAnnotation.Kind); }
public RenameRewriterParameters( RenameAnnotation renamedSymbolDeclarationAnnotation, Document document, SemanticModel semanticModel, SyntaxNode syntaxRoot, string replacementText, string originalText, ICollection <string> possibleNameConflicts, Dictionary <TextSpan, RenameLocation> renameLocations, ImmutableDictionary <TextSpan, ImmutableSortedSet <TextSpan>?> stringAndCommentTextSpans, ISet <TextSpan> conflictLocationSpans, Solution originalSolution, ISymbol renameSymbol, bool replacementTextValid, RenamedSpansTracker renameSpansTracker, bool isRenamingInStrings, bool isRenamingInComments, AnnotationTable <RenameAnnotation> renameAnnotations, CancellationToken cancellationToken) { RenamedSymbolDeclarationAnnotation = renamedSymbolDeclarationAnnotation; Document = document; SemanticModel = semanticModel; SyntaxRoot = syntaxRoot; OriginalSyntaxTree = semanticModel.SyntaxTree; ReplacementText = replacementText; OriginalText = originalText; PossibleNameConflicts = possibleNameConflicts; RenameLocations = renameLocations; StringAndCommentTextSpans = stringAndCommentTextSpans; ConflictLocationSpans = conflictLocationSpans; OriginalSolution = originalSolution; RenameSymbol = renameSymbol; ReplacementTextValid = replacementTextValid; CancellationToken = cancellationToken; RenameSpansTracker = renameSpansTracker; IsRenamingInStrings = isRenamingInStrings; IsRenamingInComments = isRenamingInComments; RenameAnnotations = renameAnnotations; }
public void CalculateCoverage_FileExists_WithLines_ReturnsCodeCoverageTable() { var annotations = new[] { new { fileName = "first", id = 1, index = 2, hitCount = 1, coverage = 100.0m, line = "first_1" }, new { fileName = "second", id = 2, index = 8, hitCount = 3, coverage = 100.0m, line = "second_2" }, new { fileName = "third", id = 3, index = 13, hitCount = 0, coverage = 0.0m, line = string.Empty } }; var annotationTable = new AnnotationTable(); foreach (var a in annotations) { annotationTable.Add(a.fileName); annotationTable[a.fileName].Add(new Annotation(a.id, a.index, a.hitCount)); } var calculator = new CodeCoverageCalculator(null, annotationTable) { FileReader = new StubFileReader { ExistsValue = true, GetLinesValue = annotations.Select(a => a.line) } }; var actualCoverage = calculator.CalculateCoverage(); var expectedCoverage = new CodeCoverageTable { Total = (decimal)2 / 3 * 100 }; foreach (var a in annotations) expectedCoverage.Add(a.fileName, a.coverage); Assert.AreEqual(expectedCoverage.Plugin, actualCoverage.Plugin); Assert.AreEqual(expectedCoverage.Total, actualCoverage.Total); Assert.AreEqual(expectedCoverage.ToString(), actualCoverage.ToString()); CollectionAssert.AreEqual(expectedCoverage, actualCoverage); }
public RenameRewriterParameters( RenameAnnotation renamedSymbolDeclarationAnnotation, Document document, SemanticModel semanticModel, SyntaxNode syntaxRoot, string replacementText, string originalText, ICollection <string> possibleNameConflicts, Dictionary <TextSpan, RenameLocation> renameLocations, ImmutableDictionary <TextSpan, ImmutableSortedSet <TextSpan>?> stringAndCommentTextSpans, ISet <TextSpan> conflictLocationSpans, Solution originalSolution, ISymbol renameSymbol, bool replacementTextValid, RenamedSpansTracker renameSpansTracker, RenameOptionSet optionSet, AnnotationTable <RenameAnnotation> renameAnnotations, CancellationToken cancellationToken ) { this.RenamedSymbolDeclarationAnnotation = renamedSymbolDeclarationAnnotation; this.Document = document; this.SemanticModel = semanticModel; this.SyntaxRoot = syntaxRoot; this.OriginalSyntaxTree = semanticModel.SyntaxTree; this.ReplacementText = replacementText; this.OriginalText = originalText; this.PossibleNameConflicts = possibleNameConflicts; this.RenameLocations = renameLocations; this.StringAndCommentTextSpans = stringAndCommentTextSpans; this.ConflictLocationSpans = conflictLocationSpans; this.OriginalSolution = originalSolution; this.RenameSymbol = renameSymbol; this.ReplacementTextValid = replacementTextValid; this.CancellationToken = cancellationToken; this.RenameSpansTracker = renameSpansTracker; this.OptionSet = optionSet; this.RenameAnnotations = renameAnnotations; }
internal void RemoveAllRenameAnnotations(IEnumerable<DocumentId> documentWithRenameAnnotations, AnnotationTable<RenameAnnotation> annotationSet, CancellationToken cancellationToken) { foreach (var documentId in documentWithRenameAnnotations) { if (this.renamedSpansTracker.IsDocumentChanged(documentId)) { var document = newSolution.GetDocument(documentId); var root = document.GetSyntaxRootAsync(cancellationToken).WaitAndGetResult(cancellationToken); var newRoot = root.ReplaceSyntax( annotationSet.GetAnnotatedNodes(root), (original, dummy) => annotationSet.WithoutAnnotations(original, annotationSet.GetAnnotations(original).ToArray()), annotationSet.GetAnnotatedTokens(root), (original, dummy) => annotationSet.WithoutAnnotations(original, annotationSet.GetAnnotations(original).ToArray()), SpecializedCollections.EmptyEnumerable<SyntaxTrivia>(), computeReplacementTrivia: null); this.intermediateSolutionContainingOnlyModifiedDocuments = this.intermediateSolutionContainingOnlyModifiedDocuments.WithDocumentSyntaxRoot(documentId, newRoot); } } this.newSolution = this.intermediateSolutionContainingOnlyModifiedDocuments; }
public RenameRewriterParameters( RenameAnnotation renamedSymbolDeclarationAnnotation, Document document, SemanticModel semanticModel, SyntaxNode syntaxRoot, string replacementText, string originalText, ICollection<string> possibleNameConflicts, Dictionary<TextSpan, RenameLocation> renameLocations, ISet<TextSpan> stringAndCommentTextSpans, ISet<TextSpan> conflictLocationSpans, Solution originalSolution, ISymbol renameSymbol, bool replacementTextValid, CancellationToken cancellationToken, RenamedSpansTracker renameSpansTracker, OptionSet optionSet, AnnotationTable<RenameAnnotation> renameAnnotations) { this.RenamedSymbolDeclarationAnnotation = renamedSymbolDeclarationAnnotation; this.Document = document; this.SemanticModel = semanticModel; this.SyntaxRoot = syntaxRoot; this.OriginalSyntaxTree = semanticModel.SyntaxTree; this.ReplacementText = replacementText; this.OriginalText = originalText; this.PossibleNameConflicts = possibleNameConflicts; this.RenameLocations = renameLocations; this.StringAndCommentTextSpans = stringAndCommentTextSpans; this.ConflictLocationSpans = conflictLocationSpans; this.OriginalSolution = originalSolution; this.RenameSymbol = renameSymbol; this.ReplacementTextValid = replacementTextValid; this.CancellationToken = cancellationToken; this.RenameSpansTracker = renameSpansTracker; this.OptionSet = optionSet; this.RenameAnnotations = renameAnnotations; }
public void CalculateCoverage_DoNotReadAnnotations_ReturnsCodeCoverageTable() { var annotations = new[] { new { fileName = "first", hitCount = 3, totalCount = 3, coverage = 100.0m, line = "first_1" }, new { fileName = "second", hitCount = 4, totalCount = 5, coverage = 80.0m, line = "second_2" }, new { fileName = "third", hitCount = 8, totalCount = 10, coverage = 80.0m, line = "third_3" }, new { fileName = "fourth", hitCount = 1, totalCount = 5, coverage = 20.0m, line = "fourth_4" }, new { fileName = "fifth", hitCount = 3, totalCount = 30, coverage = 10.0m, line = "fifth_5" } }; var annotationTable = new AnnotationTable(); int id = 0; foreach (var a in annotations) { annotationTable.Add(a.fileName); int hitCount = a.hitCount; for (int i = 0; i < a.totalCount; i++) annotationTable[a.fileName].Add(new Annotation(id++, id, hitCount-- > 0 ? 1 : 0)); } var calculator = new CodeCoverageCalculator(annotationTable); var actualCoverage = calculator.CalculateCoverage(false); var expectedCoverage = new CodeCoverageTable { Total = 35.84905660377358490566037736m }; foreach (var a in annotations) expectedCoverage.Add(a.fileName, a.coverage); Assert.AreEqual(expectedCoverage.Plugin, actualCoverage.Plugin); Assert.AreEqual(expectedCoverage.Total, actualCoverage.Total); Assert.AreEqual(expectedCoverage.ToString(), actualCoverage.ToString()); CollectionAssert.AreEqual(expectedCoverage, actualCoverage); }
public static async Task <TRoot> ReplaceSyntaxAsync <TRoot>( this TRoot root, IEnumerable <SyntaxNode> nodes, Func <SyntaxNode, SyntaxNode, CancellationToken, Task <SyntaxNode> > computeReplacementNodeAsync, IEnumerable <SyntaxToken> tokens, Func <SyntaxToken, SyntaxToken, CancellationToken, Task <SyntaxToken> > computeReplacementTokenAsync, IEnumerable <SyntaxTrivia> trivia, Func <SyntaxTrivia, SyntaxTrivia, CancellationToken, Task <SyntaxTrivia> > computeReplacementTriviaAsync, CancellationToken cancellationToken) where TRoot : SyntaxNode { // index all nodes, tokens and trivia by the full spans they cover var nodesToReplace = nodes != null?nodes.ToDictionary(n => n.FullSpan) : new Dictionary <TextSpan, SyntaxNode>(); var tokensToReplace = tokens != null?tokens.ToDictionary(t => t.FullSpan) : new Dictionary <TextSpan, SyntaxToken>(); var triviaToReplace = trivia != null?trivia.ToDictionary(t => t.FullSpan) : new Dictionary <TextSpan, SyntaxTrivia>(); var nodeReplacements = new Dictionary <SyntaxNode, SyntaxNode>(); var tokenReplacements = new Dictionary <SyntaxToken, SyntaxToken>(); var triviaReplacements = new Dictionary <SyntaxTrivia, SyntaxTrivia>(); var retryAnnotations = new AnnotationTable <object>("RetryReplace"); var spans = new List <TextSpan>(nodesToReplace.Count + tokensToReplace.Count + triviaToReplace.Count); spans.AddRange(nodesToReplace.Keys); spans.AddRange(tokensToReplace.Keys); spans.AddRange(triviaToReplace.Keys); while (spans.Count > 0) { // sort the spans of the items to be replaced so we can tell if any overlap spans.Sort((x, y) => { // order by end offset, and then by length var d = x.End - y.End; if (d == 0) { d = x.Length - y.Length; } return(d); }); // compute replacements for all nodes that will go in the same batch // only spans that do not overlap go in the same batch. TextSpan previous = default(TextSpan); foreach (var span in spans) { // only add to replacement map if we don't intersect with the previous node. This taken with the sort order // should ensure that parent nodes are not processed in the same batch as child nodes. if (previous == default(TextSpan) || !previous.IntersectsWith(span)) { if (nodesToReplace.TryGetValue(span, out var currentNode)) { var original = (SyntaxNode)retryAnnotations.GetAnnotations(currentNode).SingleOrDefault() ?? currentNode; var newNode = await computeReplacementNodeAsync(original, currentNode, cancellationToken).ConfigureAwait(false); nodeReplacements[currentNode] = newNode; } else if (tokensToReplace.TryGetValue(span, out var currentToken)) { var original = (SyntaxToken)retryAnnotations.GetAnnotations(currentToken).SingleOrDefault(); if (original == default(SyntaxToken)) { original = currentToken; } var newToken = await computeReplacementTokenAsync(original, currentToken, cancellationToken).ConfigureAwait(false); tokenReplacements[currentToken] = newToken; } else if (triviaToReplace.TryGetValue(span, out var currentTrivia)) { var original = (SyntaxTrivia)retryAnnotations.GetAnnotations(currentTrivia).SingleOrDefault(); if (original == default(SyntaxTrivia)) { original = currentTrivia; } var newTrivia = await computeReplacementTriviaAsync(original, currentTrivia, cancellationToken).ConfigureAwait(false); triviaReplacements[currentTrivia] = newTrivia; } } previous = span; } bool retryNodes = false; bool retryTokens = false; bool retryTrivia = false; // replace nodes in batch // submit all nodes so we can annotate the ones we don't replace root = root.ReplaceSyntax( nodes: nodesToReplace.Values, computeReplacementNode: (original, rewritten) => { if (rewritten != original || !nodeReplacements.TryGetValue(original, out var replaced)) { // the subtree did change, or we didn't have a replacement for it in this batch // so we need to add an annotation so we can find this node again for the next batch. replaced = retryAnnotations.WithAdditionalAnnotations(rewritten, original); retryNodes = true; } return(replaced); }, tokens: tokensToReplace.Values, computeReplacementToken: (original, rewritten) => { if (rewritten != original || !tokenReplacements.TryGetValue(original, out var replaced)) { // the subtree did change, or we didn't have a replacement for it in this batch // so we need to add an annotation so we can find this node again for the next batch. replaced = retryAnnotations.WithAdditionalAnnotations(rewritten, original); retryTokens = true; } return(replaced); }, trivia: triviaToReplace.Values, computeReplacementTrivia: (original, rewritten) => { if (!triviaReplacements.TryGetValue(original, out var replaced)) { // the subtree did change, or we didn't have a replacement for it in this batch // so we need to add an annotation so we can find this node again for the next batch. replaced = retryAnnotations.WithAdditionalAnnotations(rewritten, original); retryTrivia = true; } return(replaced); }); nodesToReplace.Clear(); tokensToReplace.Clear(); triviaToReplace.Clear(); spans.Clear(); // prepare next batch out of all remaining annotated nodes if (retryNodes) { nodesToReplace = retryAnnotations.GetAnnotatedNodes(root).ToDictionary(n => n.FullSpan); spans.AddRange(nodesToReplace.Keys); } if (retryTokens) { tokensToReplace = retryAnnotations.GetAnnotatedTokens(root).ToDictionary(t => t.FullSpan); spans.AddRange(tokensToReplace.Keys); } if (retryTrivia) { triviaToReplace = retryAnnotations.GetAnnotatedTrivia(root).ToDictionary(t => t.FullSpan); spans.AddRange(triviaToReplace.Keys); } } return(root); }
internal async Task <Solution> SimplifyAsync(Solution solution, IEnumerable <DocumentId> documentIds, bool replacementTextValid, AnnotationTable <RenameAnnotation> renameAnnotations, CancellationToken cancellationToken) { foreach (var documentId in documentIds) { if (this.IsDocumentChanged(documentId)) { var document = solution.GetDocument(documentId); if (replacementTextValid) { var optionSet = solution.Workspace.Options; document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, optionSet, cancellationToken).ConfigureAwait(false); document = await Formatter.FormatAsync(document, Formatter.Annotation, cancellationToken : cancellationToken).ConfigureAwait(false); } // Simplification may have removed escaping and formatted whitespace. We need to update // our list of modified spans accordingly if (_documentToModifiedSpansMap.ContainsKey(documentId)) { _documentToModifiedSpansMap[documentId].Clear(); } if (_documentToComplexifiedSpansMap.ContainsKey(documentId)) { _documentToComplexifiedSpansMap[documentId].Clear(); } var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // First, get all the complexified statements var nodeAnnotations = renameAnnotations.GetAnnotatedNodesAndTokens <RenameNodeSimplificationAnnotation>(root) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations <RenameNodeSimplificationAnnotation>(x).First(), (SyntaxNode)x)); HashSet <SyntaxToken> modifiedTokensInComplexifiedStatements = new HashSet <SyntaxToken>(); foreach (var annotationAndNode in nodeAnnotations) { var oldSpan = annotationAndNode.Item1.OriginalTextSpan; var node = annotationAndNode.Item2; var annotationAndTokens2 = renameAnnotations.GetAnnotatedNodesAndTokens <RenameTokenSimplificationAnnotation>(node) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations <RenameTokenSimplificationAnnotation>(x).First(), (SyntaxToken)x)); List <ValueTuple <TextSpan, TextSpan> > modifiedSubSpans = new List <ValueTuple <TextSpan, TextSpan> >(); foreach (var annotationAndToken in annotationAndTokens2) { modifiedTokensInComplexifiedStatements.Add(annotationAndToken.Item2); modifiedSubSpans.Add(ValueTuple.Create(annotationAndToken.Item1.OriginalTextSpan, annotationAndToken.Item2.Span)); } AddComplexifiedSpan(documentId, oldSpan, node.Span, modifiedSubSpans); } // Now process the rest of the renamed spans var annotationAndTokens = renameAnnotations.GetAnnotatedNodesAndTokens <RenameTokenSimplificationAnnotation>(root) .Where(x => !modifiedTokensInComplexifiedStatements.Contains((SyntaxToken)x)) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations <RenameTokenSimplificationAnnotation>(x).First(), (SyntaxToken)x)); foreach (var annotationAndToken in annotationAndTokens) { AddModifiedSpan(documentId, annotationAndToken.Item1.OriginalTextSpan, annotationAndToken.Item2.Span); } var annotationAndTrivias = renameAnnotations.GetAnnotatedTrivia <RenameTokenSimplificationAnnotation>(root) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations <RenameTokenSimplificationAnnotation>(x).First(), x)); foreach (var annotationAndTrivia in annotationAndTrivias) { AddModifiedSpan(documentId, annotationAndTrivia.Item1.OriginalTextSpan, annotationAndTrivia.Item2.Span); } solution = document.Project.Solution; } } return(solution); }
internal async Task<Solution> SimplifyAsync(Solution solution, IEnumerable<DocumentId> documentIds, bool replacementTextValid, AnnotationTable<RenameAnnotation> renameAnnotations, CancellationToken cancellationToken) { foreach (var documentId in documentIds) { if (this.IsDocumentChanged(documentId)) { var document = solution.GetDocument(documentId); if (replacementTextValid) { var optionSet = solution.Workspace.Options; document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, optionSet, cancellationToken).ConfigureAwait(false); document = await Formatter.FormatAsync(document, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false); } // Simplification may have removed escaping and formatted whitespace. We need to update // our list of modified spans accordingly if (_documentToModifiedSpansMap.ContainsKey(documentId)) { _documentToModifiedSpansMap[documentId].Clear(); } if (_documentToComplexifiedSpansMap.ContainsKey(documentId)) { _documentToComplexifiedSpansMap[documentId].Clear(); } var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // First, get all the complexified statements var nodeAnnotations = renameAnnotations.GetAnnotatedNodesAndTokens<RenameNodeSimplificationAnnotation>(root) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations<RenameNodeSimplificationAnnotation>(x).First(), (SyntaxNode)x)); HashSet<SyntaxToken> modifiedTokensInComplexifiedStatements = new HashSet<SyntaxToken>(); foreach (var annotationAndNode in nodeAnnotations) { var oldSpan = annotationAndNode.Item1.OriginalTextSpan; var node = annotationAndNode.Item2; var annotationAndTokens2 = renameAnnotations.GetAnnotatedNodesAndTokens<RenameTokenSimplificationAnnotation>(node) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations<RenameTokenSimplificationAnnotation>(x).First(), (SyntaxToken)x)); List<ValueTuple<TextSpan, TextSpan>> modifiedSubSpans = new List<ValueTuple<TextSpan, TextSpan>>(); foreach (var annotationAndToken in annotationAndTokens2) { modifiedTokensInComplexifiedStatements.Add(annotationAndToken.Item2); modifiedSubSpans.Add(ValueTuple.Create(annotationAndToken.Item1.OriginalTextSpan, annotationAndToken.Item2.Span)); } AddComplexifiedSpan(documentId, oldSpan, node.Span, modifiedSubSpans); } // Now process the rest of the renamed spans var annotationAndTokens = renameAnnotations.GetAnnotatedNodesAndTokens<RenameTokenSimplificationAnnotation>(root) .Where(x => !modifiedTokensInComplexifiedStatements.Contains((SyntaxToken)x)) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations<RenameTokenSimplificationAnnotation>(x).First(), (SyntaxToken)x)); foreach (var annotationAndToken in annotationAndTokens) { AddModifiedSpan(documentId, annotationAndToken.Item1.OriginalTextSpan, annotationAndToken.Item2.Span); } var annotationAndTrivias = renameAnnotations.GetAnnotatedTrivia<RenameTokenSimplificationAnnotation>(root) .Select(x => Tuple.Create(renameAnnotations.GetAnnotations<RenameTokenSimplificationAnnotation>(x).First(), (SyntaxTrivia)x)); foreach (var annotationAndTrivia in annotationAndTrivias) { AddModifiedSpan(documentId, annotationAndTrivia.Item1.OriginalTextSpan, annotationAndTrivia.Item2.Span); } solution = document.Project.Solution; } } return solution; }
internal async Task RemoveAllRenameAnnotationsAsync(IEnumerable <DocumentId> documentWithRenameAnnotations, AnnotationTable <RenameAnnotation> annotationSet, CancellationToken cancellationToken) { foreach (var documentId in documentWithRenameAnnotations) { if (_renamedSpansTracker.IsDocumentChanged(documentId)) { var document = _newSolution.GetDocument(documentId); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // For the computeReplacementToken and computeReplacementNode functions, use // the "updated" node to maintain any annotation removals from descendants. var newRoot = root.ReplaceSyntax( nodes: annotationSet.GetAnnotatedNodes(root), computeReplacementNode: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()), tokens: annotationSet.GetAnnotatedTokens(root), computeReplacementToken: (original, updated) => annotationSet.WithoutAnnotations(updated, annotationSet.GetAnnotations(updated).ToArray()), trivia: SpecializedCollections.EmptyEnumerable <SyntaxTrivia>(), computeReplacementTrivia: null); _intermediateSolutionContainingOnlyModifiedDocuments = _intermediateSolutionContainingOnlyModifiedDocuments.WithDocumentSyntaxRoot(documentId, newRoot, PreservationMode.PreserveIdentity); } } _newSolution = _intermediateSolutionContainingOnlyModifiedDocuments; }
public RenameRewriter(RenameRewriterParameters parameters) : base(visitIntoStructuredTrivia: true) { this.documentId = parameters.Document.Id; this.renameRenamableSymbolDeclaration = parameters.RenamedSymbolDeclarationAnnotation; this.solution = parameters.OriginalSolution; this.replacementText = parameters.ReplacementText; this.originalText = parameters.OriginalText; this.possibleNameConflicts = parameters.PossibleNameConflicts; this.renameLocations = parameters.RenameLocations; this.conflictLocations = parameters.ConflictLocationSpans; this.cancellationToken = parameters.CancellationToken; this.semanticModel = (SemanticModel)parameters.SemanticModel; this.renamedSymbol = parameters.RenameSymbol; this.replacementTextValid = parameters.ReplacementTextValid; this.renameSpansTracker = parameters.RenameSpansTracker; this.isRenamingInStrings = parameters.OptionSet.GetOption(RenameOptions.RenameInStrings); this.isRenamingInComments = parameters.OptionSet.GetOption(RenameOptions.RenameInComments); this.stringAndCommentTextSpans = parameters.StringAndCommentTextSpans; this.renameAnnotations = parameters.RenameAnnotations; this.aliasSymbol = this.renamedSymbol as IAliasSymbol; this.renamableDeclarationLocation = this.renamedSymbol.Locations.Where(loc => loc.IsInSource && loc.SourceTree == semanticModel.SyntaxTree).FirstOrDefault(); this.isVerbatim = this.replacementText.StartsWith("@"); this.simplificationService = LanguageService.GetService<ISimplificationService>(parameters.Document); }
private void InternalBeginAnnotation <T>(Key <T> key, T value) { AnnotationTable <T> annotationTable = GetAnnotationTable(key, true); annotationTable.BeginValue(CharCount, value); }
public CodeCoverageCalculator(AnnotationTable annotationTable) : this (null, annotationTable) { }
public CodeCoverageCalculator(FileInfo annotationFile, AnnotationTable annotationTable) { FileReader = new AnnotationFileReader(annotationFile); _annotationTable = annotationTable; }
public RenameRewriter(RenameRewriterParameters parameters) : base(visitIntoStructuredTrivia: true) { _documentId = parameters.Document.Id; _renameRenamableSymbolDeclaration = parameters.RenamedSymbolDeclarationAnnotation; _solution = parameters.OriginalSolution; _replacementText = parameters.ReplacementText; _originalText = parameters.OriginalText; _possibleNameConflicts = parameters.PossibleNameConflicts; _renameLocations = parameters.RenameLocations; _conflictLocations = parameters.ConflictLocationSpans; _cancellationToken = parameters.CancellationToken; _semanticModel = parameters.SemanticModel; _renamedSymbol = parameters.RenameSymbol; _replacementTextValid = parameters.ReplacementTextValid; _renameSpansTracker = parameters.RenameSpansTracker; _isRenamingInStrings = parameters.OptionSet.GetOption(RenameOptions.RenameInStrings); _isRenamingInComments = parameters.OptionSet.GetOption(RenameOptions.RenameInComments); _stringAndCommentTextSpans = parameters.StringAndCommentTextSpans; _renameAnnotations = parameters.RenameAnnotations; _aliasSymbol = _renamedSymbol as IAliasSymbol; _renamableDeclarationLocation = _renamedSymbol.Locations.FirstOrDefault(loc => loc.IsInSource && loc.SourceTree == _semanticModel.SyntaxTree); _isVerbatim = _replacementText.StartsWith("@", StringComparison.Ordinal); _simplificationService = parameters.Document.Project.LanguageServices.GetService<ISimplificationService>(); _semanticFactsService = parameters.Document.Project.LanguageServices.GetService<ISemanticFactsService>(); }
public Annotator() { AnnotationIndexes = new Dictionary<string, int>(); AnnotationTable = new AnnotationTable(); Config = Program.Config; }
internal void RemoveAllRenameAnnotations(IEnumerable <DocumentId> documentWithRenameAnnotations, AnnotationTable <RenameAnnotation> annotationSet, CancellationToken cancellationToken) { foreach (var documentId in documentWithRenameAnnotations) { if (this.renamedSpansTracker.IsDocumentChanged(documentId)) { var document = newSolution.GetDocument(documentId); var root = document.GetSyntaxRootAsync(cancellationToken).WaitAndGetResult(cancellationToken); var newRoot = root.ReplaceSyntax( annotationSet.GetAnnotatedNodes(root), (original, dummy) => annotationSet.WithoutAnnotations(original, annotationSet.GetAnnotations(original).ToArray()), annotationSet.GetAnnotatedTokens(root), (original, dummy) => annotationSet.WithoutAnnotations(original, annotationSet.GetAnnotations(original).ToArray()), SpecializedCollections.EmptyEnumerable <SyntaxTrivia>(), computeReplacementTrivia: null); this.intermediateSolutionContainingOnlyModifiedDocuments = this.intermediateSolutionContainingOnlyModifiedDocuments.WithDocumentSyntaxRoot(documentId, newRoot, PreservationMode.PreserveIdentity); } } this.newSolution = this.intermediateSolutionContainingOnlyModifiedDocuments; }