protected override Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(CancellationToken cancellationToken) { SourceText text; StateMachine stateMachine; ITextBuffer textBuffer; if (_document.TryGetText(out text)) { textBuffer = text.Container.TryGetTextBuffer(); if (textBuffer == null) { Environment.FailFast(string.Format("document with name {0} is open but textBuffer is null. Textcontainer is of type {1}. SourceText is: {2}", _document.Name, text.Container.GetType().FullName, text.ToString())); } if (textBuffer.Properties.TryGetProperty(typeof(StateMachine), out stateMachine)) { TrackingSession trackingSession; if (stateMachine.CanInvokeRename(out trackingSession, cancellationToken: cancellationToken)) { var snapshotSpan = stateMachine.TrackingSession.TrackingSpan.GetSpan(stateMachine.Buffer.CurrentSnapshot); var str = string.Format(EditorFeaturesResources.RenameTo, stateMachine.TrackingSession.OriginalName, snapshotSpan.GetText()); var committerOperation = new RenameTrackingCommitterOperation(new RenameTrackingCommitter(stateMachine, snapshotSpan, _refactorNotifyServices, _undoHistoryRegistry, str, showPreview: _showPreview)); return(Task.FromResult(SpecializedCollections.SingletonEnumerable(committerOperation as CodeActionOperation))); } Debug.Assert(false, "RenameTracking codefix invoked on a document with a StateMachine which cannot invoke rename."); } } Debug.Assert(false, "RenameTracking codefix invoked on a document for which the text or StateMachine is not available."); return(SpecializedTasks.EmptyEnumerable <CodeActionOperation>()); }
public Task <IEnumerable <ITagSpan <AbstractNavigatableReferenceHighlightingTag> > > ProduceTagsAsync( IEnumerable <DocumentSnapshotSpan> snapshotSpans, SnapshotPoint?caretPosition, CancellationToken cancellationToken) { // NOTE(cyrusn): Normally we'd limit ourselves to producing tags in the span we were // asked about. However, we want to produce all tags here so that the user can actually // navigate between all of them using the appropriate tag navigation commands. If we // don't generate all the tags then the user will cycle through an incorrect subset. if (caretPosition == null) { return(SpecializedTasks.EmptyEnumerable <ITagSpan <AbstractNavigatableReferenceHighlightingTag> >()); } var position = caretPosition.Value; Workspace workspace; if (!Workspace.TryGetWorkspace(position.Snapshot.AsText().Container, out workspace)) { return(SpecializedTasks.EmptyEnumerable <ITagSpan <AbstractNavigatableReferenceHighlightingTag> >()); } var document = snapshotSpans.First(vt => vt.SnapshotSpan.Snapshot == position.Snapshot).Document; if (document == null) { return(SpecializedTasks.EmptyEnumerable <ITagSpan <AbstractNavigatableReferenceHighlightingTag> >()); } return(ProduceTagsAsync(snapshotSpans, position, workspace, document, cancellationToken)); }
protected override Task <IEnumerable <Document> > DetermineDocumentsToSearchAsync( TSymbol symbol, Project project, IImmutableSet <Document> documents, CancellationToken cancellationToken) { var location = symbol.Locations.FirstOrDefault(); if (location == null || !location.IsInSource) { return(SpecializedTasks.EmptyEnumerable <Document>()); } var document = project.GetDocument(location.SourceTree); if (document == null) { return(SpecializedTasks.EmptyEnumerable <Document>()); } if (documents != null && !documents.Contains(document)) { return(SpecializedTasks.EmptyEnumerable <Document>()); } return(Task.FromResult(SpecializedCollections.SingletonEnumerable <Document>(document))); }
private Task <IEnumerable <ISymbol> > GetSymbolsAsync( Project project, SyntaxNode node, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); // See if the name binds. If it does, there's nothing further we need to do. if (ExpressionBinds(node, semanticModel, cancellationToken, checkForExtensionMethods: true)) { return(SpecializedTasks.EmptyEnumerable <ISymbol>()); } string name; int arity; syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity); if (name == null) { return(SpecializedTasks.EmptyEnumerable <ISymbol>()); } return(SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken)); }
protected override Task <IEnumerable <ReferenceLocation> > FindReferencesInDocumentAsync( IMethodSymbol methodSymbol, Document document, CancellationToken cancellationToken) { return(SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); }
private static Task <IEnumerable <SymbolAndProjectId <INamedTypeSymbol> > > FindDerivedClassesAsync( SymbolAndProjectId <INamedTypeSymbol> type, Solution solution, IImmutableSet <Project> projects, bool transitive, CancellationToken cancellationToken) { if (s_isNonSealedClass(type.Symbol)) { Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> metadataTypeMatches = (set, metadataType) => TypeDerivesFrom(set, metadataType, transitive); Func <SymbolAndProjectIdSet, INamedTypeSymbol, bool> sourceTypeImmediatelyMatches = (set, metadataType) => set.Contains(SymbolAndProjectId.Create(metadataType.BaseType?.OriginalDefinition, projectId: null)); return(FindTypesAsync(type, solution, projects, metadataTypeMatches: metadataTypeMatches, sourceTypeImmediatelyMatches: sourceTypeImmediatelyMatches, shouldContinueSearching: s_isNonSealedClass, transitive: transitive, cancellationToken: cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <SymbolAndProjectId <INamedTypeSymbol> >()); }
protected override Task <IEnumerable <SymbolAndProjectId> > DetermineCascadedSymbolsAsync( SymbolAndProjectId <ITypeParameterSymbol> symbolAndProjectId, Solution solution, IImmutableSet <Project> projects, CancellationToken cancellationToken) { var symbol = symbolAndProjectId.Symbol; var method = (IMethodSymbol)symbol.ContainingSymbol; var ordinal = method.TypeParameters.IndexOf(symbol); if (ordinal >= 0) { if (method.PartialDefinitionPart != null && ordinal < method.PartialDefinitionPart.TypeParameters.Length) { return(Task.FromResult(SpecializedCollections.SingletonEnumerable( symbolAndProjectId.WithSymbol((ISymbol)method.PartialDefinitionPart.TypeParameters[ordinal])))); } if (method.PartialImplementationPart != null && ordinal < method.PartialImplementationPart.TypeParameters.Length) { return(Task.FromResult(SpecializedCollections.SingletonEnumerable( symbolAndProjectId.WithSymbol((ISymbol)method.PartialImplementationPart.TypeParameters[ordinal])))); } } return(SpecializedTasks.EmptyEnumerable <SymbolAndProjectId>()); }
protected override Task <IEnumerable <SymbolAndProjectId> > DetermineCascadedSymbolsAsync( SymbolAndProjectId <IMethodSymbol> symbol, Solution solution, IImmutableSet <Project> projects, CancellationToken cancellationToken) { return(SpecializedTasks.EmptyEnumerable <SymbolAndProjectId>()); }
protected override Task <IEnumerable <Document> > DetermineDocumentsToSearchAsync( IMethodSymbol symbol, Project project, IImmutableSet <Document> documents, CancellationToken cancellationToken) { return(SpecializedTasks.EmptyEnumerable <Document>()); }
public Task <IEnumerable <ReferenceLocation> > FindReferencesInDocumentAsync( SymbolAndProjectId symbolAndProjectId, Document document, CancellationToken cancellationToken) { var symbol = symbolAndProjectId.Symbol; return(symbol is TSymbol && CanFind((TSymbol)symbol) ? FindReferencesInDocumentAsync((TSymbol)symbol, document, cancellationToken) : SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); }
public override Task <IEnumerable <Diagnostic> > GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) { if (ProjectDiagnosticsMap.TryGetValue(project, out var diagnostics)) { return(Task.FromResult <IEnumerable <Diagnostic> >(diagnostics)); } return(SpecializedTasks.EmptyEnumerable <Diagnostic>()); }
public Task <IEnumerable <DiagnosticData> > GetDiagnosticsForSpanAsync(Document document, TextSpan range, bool includeSuppressedDiagnostics = false, CancellationToken cancellationToken = default(CancellationToken)) { if (_map.TryGetValue(document.Project.Solution.Workspace, out var analyzer)) { // always make sure that analyzer is called on background thread. return(Task.Run(() => analyzer.GetDiagnosticsForSpanAsync(document, range, includeSuppressedDiagnostics, cancellationToken), cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <DiagnosticData>()); }
public Task <IEnumerable <DiagnosticData> > GetDiagnosticsForSpanAsync(Document document, TextSpan range, string?diagnosticId = null, bool includeSuppressedDiagnostics = false, Func <string, IDisposable?>?addOperationScope = null, CancellationToken cancellationToken = default) { if (_map.TryGetValue(document.Project.Solution.Workspace, out var analyzer)) { // always make sure that analyzer is called on background thread. return(Task.Run(() => analyzer.GetDiagnosticsForSpanAsync(document, range, diagnosticId, includeSuppressedDiagnostics, blockForData: true, addOperationScope, cancellationToken), cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <DiagnosticData>()); }
protected override Task <IEnumerable <ISymbol> > DetermineCascadedSymbolsAsync(IFieldSymbol symbol, Solution solution, IImmutableSet <Project> projects, CancellationToken cancellationToken) { if (symbol.AssociatedSymbol != null) { return(Task.FromResult <IEnumerable <ISymbol> >(new ISymbol[] { symbol.AssociatedSymbol })); } else { return(SpecializedTasks.EmptyEnumerable <ISymbol>()); } }
public Task <IEnumerable <DiagnosticData> > GetDiagnosticsForSpanAsync(Document document, TextSpan range, CancellationToken cancellationToken) { DiagnosticIncrementalAnalyzer analyzer; if (this.map.TryGetValue(document.Project.Solution.Workspace, out analyzer)) { // always make sure that analyzer is called on background thread. return(Task.Run(async() => await analyzer.GetDiagnosticsAsync(document, range, cancellationToken).ConfigureAwait(false), cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <DiagnosticData>()); }
public override Task <IEnumerable <ITagSpan <BraceHighlightTag> > > ProduceTagsAsync( Document document, SnapshotSpan snapshotSpan, int?caretPosition, CancellationToken cancellationToken) { var snapshot = snapshotSpan.Snapshot; if (!caretPosition.HasValue || document == null) { return(SpecializedTasks.EmptyEnumerable <ITagSpan <BraceHighlightTag> >()); } return(ProduceTagsAsync(document, snapshotSpan.Snapshot, caretPosition.Value, cancellationToken)); }
protected override async Task <IEnumerable <CodeActionOperation> > ComputePreviewOperationsAsync(CancellationToken cancellationToken) { if (!_document.Options.GetOption(FeatureOnOffOptions.RenameTrackingPreview) || !TryInitializeRenameTrackingCommitter(cancellationToken)) { return(await SpecializedTasks.EmptyEnumerable <CodeActionOperation>().ConfigureAwait(false)); } var solutionSet = await _renameTrackingCommitter.RenameSymbolAsync(cancellationToken).ConfigureAwait(false); return(SpecializedCollections.SingletonEnumerable( (CodeActionOperation) new ApplyChangesOperation(solutionSet.RenamedSolution))); }
private Task <IEnumerable <ReferenceLocation> > FindAttributeReferencesAsync( IMethodSymbol symbol, Document document, CancellationToken cancellationToken) { var syntaxFacts = document.GetLanguageService <ISyntaxFactsService>(); string simpleName; return(TryGetNameWithoutAttributeSuffix(symbol.ContainingType.Name, syntaxFacts, out simpleName) ? FindReferencesInDocumentUsingIdentifierAsync(symbol, simpleName, document, cancellationToken) : SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); }
private static Task <IEnumerable <ReferenceLocation> > FindAttributeReferencesAsync( INamedTypeSymbol namedType, Document document, CancellationToken cancellationToken) { var symbolsMatch = GetStandardSymbolsMatchFunction(namedType, null, document.Project.Solution, cancellationToken); var syntaxFacts = document.GetLanguageService <ISyntaxFactsService>(); string simpleName; return(TryGetNameWithoutAttributeSuffix(namedType.Name, syntaxFacts, out simpleName) ? FindReferencesInDocumentUsingIdentifierAsync(simpleName, document, symbolsMatch, cancellationToken) : SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); }
protected override Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(object options, CancellationToken cancellationToken) { if (options is ChangeSignatureOptionsResult changeSignatureOptions && !changeSignatureOptions.IsCancelled) { var changeSignatureResult = _changeSignatureService.ChangeSignatureWithContext(_context, changeSignatureOptions, cancellationToken); if (changeSignatureResult.Succeeded) { return(Task.FromResult <IEnumerable <CodeActionOperation> >(new CodeActionOperation[] { new ApplyChangesOperation(changeSignatureResult.UpdatedSolution) })); } } return(SpecializedTasks.EmptyEnumerable <CodeActionOperation>()); }
/// <summary> /// Find the declared symbols from either source, referenced projects or metadata assemblies with the specified name. /// </summary> public static Task <IEnumerable <ISymbol> > FindDeclarationsAsync(Project project, string name, bool ignoreCase, CancellationToken cancellationToken = default(CancellationToken)) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (string.IsNullOrWhiteSpace(name)) { return(SpecializedTasks.EmptyEnumerable <ISymbol>()); } return(FindDeclarationsAsync(project, SearchQuery.Create(name, ignoreCase), cancellationToken: cancellationToken)); }
public Task <IEnumerable <SymbolAndProjectId> > DetermineCascadedSymbolsAsync( SymbolAndProjectId symbolAndProjectId, Solution solution, IImmutableSet <Project> projects, CancellationToken cancellationToken) { var symbol = symbolAndProjectId.Symbol; if (symbol is TSymbol && CanFind((TSymbol)symbol)) { return(DetermineCascadedSymbolsAsync( symbolAndProjectId.WithSymbol((TSymbol)symbol), solution, projects, cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <SymbolAndProjectId>()); }
protected override Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(CancellationToken cancellationToken) { // Invoked directly without previewing. if (_renameTrackingCommitter == null) { if (!TryInitializeRenameTrackingCommitter(cancellationToken)) { return(SpecializedTasks.EmptyEnumerable <CodeActionOperation>()); } } var committerOperation = new RenameTrackingCommitterOperation(_renameTrackingCommitter); return(Task.FromResult(SpecializedCollections.SingletonEnumerable(committerOperation as CodeActionOperation))); }
public Task <IEnumerable <ITagSpan <TTag> > > ProduceTagsAsync(IEnumerable <DocumentSnapshotSpan> snapshotSpans, SnapshotPoint?caretPosition, CancellationToken cancellationToken) { // This abstract class should only be used in places where the tagger will only ever be analyzing at most one // document and span. The .Single()s are appropriate here, and if you find yourself "fixing" a bug by replacing // them with .First() you don't understand this class in the first place. var snapshotSpan = snapshotSpans.Single().SnapshotSpan; var document = snapshotSpans.Single().Document; if (document == null) { return(SpecializedTasks.EmptyEnumerable <ITagSpan <TTag> >()); } return(ProduceTagsAsync(document, snapshotSpan, GetCaretPosition(caretPosition, snapshotSpan), cancellationToken)); }
private static Task <IEnumerable <ReferencedSymbol> > FindCallReferencesAsync( Solution solution, ISymbol symbol, IImmutableSet <Document> documents, CancellationToken cancellationToken = default(CancellationToken)) { if (symbol != null) { if (symbol.Kind == SymbolKind.Event || symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.Property) { return(SymbolFinder.FindReferencesAsync(symbol, solution, documents, cancellationToken)); } } return(SpecializedTasks.EmptyEnumerable <ReferencedSymbol>()); }
private Task <IEnumerable <ReferenceLocation> > FindPredefinedTypeReferencesAsync( IMethodSymbol symbol, Document document, CancellationToken cancellationToken) { var predefinedType = symbol.ContainingType.SpecialType.ToPredefinedType(); if (predefinedType == PredefinedType.None) { return(SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); } var syntaxFacts = document.GetLanguageService <ISyntaxFactsService>(); return(FindReferencesInDocumentAsync(symbol, document, t => IsPotentialReference(predefinedType, syntaxFacts, t), cancellationToken)); }
public static Task <IEnumerable <INamedTypeSymbol> > GetTypesImmediatelyDerivedFromClassesAsync( INamedTypeSymbol type, Solution solution, CancellationToken cancellationToken) { if (type != null && type.TypeKind == TypeKind.Class) { return(GetDependentTypesAsync( type, solution, null, (t1, t2) => t1.BaseType == t2, s_derivedClassesCache, cancellationToken)); } return(SpecializedTasks.EmptyEnumerable <INamedTypeSymbol>()); }
internal static Task <IEnumerable <ISymbol> > FindDeclarationsAsync( Project project, SearchQuery query, SymbolFilter filter, CancellationToken cancellationToken) { if (project == null) { throw new ArgumentNullException(nameof(project)); } if (query.Name != null && string.IsNullOrWhiteSpace(query.Name)) { return(SpecializedTasks.EmptyEnumerable <ISymbol>()); } using (Logger.LogBlock(FunctionId.SymbolFinder_FindDeclarationsAsync, cancellationToken)) { return(FindDeclarationsAsyncImpl(project, query, filter, cancellationToken)); } }
protected override Task <IEnumerable <SymbolAndProjectId> > DetermineCascadedSymbolsAsync( SymbolAndProjectId <IFieldSymbol> symbolAndProjectId, Solution solution, IImmutableSet <Project> projects, CancellationToken cancellationToken) { var symbol = symbolAndProjectId.Symbol; if (symbol.AssociatedSymbol != null) { return(Task.FromResult( SpecializedCollections.SingletonEnumerable( symbolAndProjectId.WithSymbol(symbol.AssociatedSymbol)))); } else { return(SpecializedTasks.EmptyEnumerable <SymbolAndProjectId>()); } }
private static Task <IEnumerable <ReferenceLocation> > FindPredefinedTypeReferencesAsync( INamedTypeSymbol symbol, Document document, CancellationToken cancellationToken) { var predefinedType = symbol.SpecialType.ToPredefinedType(); if (predefinedType == PredefinedType.None) { return(SpecializedTasks.EmptyEnumerable <ReferenceLocation>()); } var syntaxFacts = document.GetLanguageService <ISyntaxFactsService>(); return(FindReferencesInDocumentAsync(symbol, document, t => IsPotentialReference(predefinedType, syntaxFacts, t), (t, m) => ValueTuple.Create(true, CandidateReason.None), cancellationToken)); }