public override Task <CompletionDescription> GetDescriptionAsync(Document document, CompletionItem item, CancellationToken cancellationToken) { if (!item.Properties.TryGetValue(DescriptionKey, out var description)) { return(SpecializedTasks.Default <CompletionDescription>()); } return(Task.FromResult(CompletionDescription.Create( ImmutableArray.Create(new TaggedText(TextTags.Text, description))))); }
public static Task <RemoteHostClient> TryGetRemoteHostClientAsync( this Workspace workspace, Option <bool> featureOption, CancellationToken cancellationToken) { if (!workspace.IsOutOfProcessEnabled(featureOption)) { return(SpecializedTasks.Default <RemoteHostClient>()); } return(workspace.TryGetRemoteHostClientAsync(cancellationToken)); }
private Task OnSettingChangedAsync(object sender, PropertyChangedEventArgs args) { IOption option; if (this.StorageKeyToOptionMap.TryGetValue(args.PropertyName, out option)) { this.SetChangedOption(_optionService, option, LanguageName); } return(SpecializedTasks.Default <object>()); }
public static Task <OptionSet> GetDocumentOptionSetAsync(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken) { var workspaceAnalyzerOptions = analyzerOptions as WorkspaceAnalyzerOptions; if (workspaceAnalyzerOptions == null) { return(SpecializedTasks.Default <OptionSet>()); } return(workspaceAnalyzerOptions.GetDocumentOptionSetAsync(syntaxTree, cancellationToken)); }
public static Task <RemoteHostClient?> TryGetClientAsync(Workspace workspace, CancellationToken cancellationToken) { var service = workspace.Services.GetService <IRemoteHostClientService>(); if (service == null) { return(SpecializedTasks.Default <RemoteHostClient?>()); } return(service.TryGetRemoteHostClientAsync(cancellationToken)); }
public Task <string> GetSnippetExpansionNoteForCompletionItemAsync(CompletionItem completionItem, Workspace workspace) { var insertionText = completionItem.CompletionProvider.GetTextChange(completionItem, '\t').NewText; var snippetInfoService = workspace.Services.GetLanguageServices(GetLanguageName()).GetService <ISnippetInfoService>(); if (snippetInfoService != null && snippetInfoService.SnippetShortcutExists_NonBlocking(insertionText)) { return(Task.FromResult(string.Format(FeaturesResources.NoteTabTwiceToInsertTheSnippet, insertionText))); } return(SpecializedTasks.Default <string>()); }
public Task <Document> ImplementAbstractClassAsync(Document document, SemanticModel model, SyntaxNode node, CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.Refactoring_ImplementAbstractClass, cancellationToken)) { var state = State.Generate(this, document, model, node, cancellationToken); if (state == null) { return(SpecializedTasks.Default <Document>()); } return(new Editor(document, model, state).GetEditAsync(cancellationToken)); } }
public override Task <object?> HandleRequestAsync( LSP.DidCloseTextDocumentParams request, RequestContext context, CancellationToken cancellationToken ) { // GetTextDocumentIdentifier returns null to avoid creating the solution, so the queue is not able to log the uri. context.TraceInformation($"didClose for {request.TextDocument.Uri}"); context.StopTracking(request.TextDocument.Uri); return(SpecializedTasks.Default <object>()); }
private static Task <CompletionItemGroup> GetGroupAsync( ICompletionProvider provider, Document documentOpt, SourceText text, int position, CompletionTriggerInfo triggerInfo, CancellationToken cancellationToken) { return(provider is ITextCompletionProvider ? Task.FromResult(((ITextCompletionProvider)provider).GetGroup(text, position, triggerInfo, cancellationToken)) : documentOpt != null ? provider.GetGroupAsync(documentOpt, position, triggerInfo, cancellationToken) : SpecializedTasks.Default <CompletionItemGroup>()); }
public Task <RemoteHostClient> CreateAsync(Workspace workspace, CancellationToken cancellationToken) { try { // this is the point where we can create different kind of remote host client in future (cloud or etc) return(ServiceHubRemoteHostClient.CreateAsync(workspace, cancellationToken)); } catch { // currently there is so many moving parts that cause, in some branch/drop, // service hub not to work. in such places (ex, Jenkins), rather than crashing VS // right away, let VS run without service hub enabled. return(SpecializedTasks.Default <RemoteHostClient>()); } }
public async Task <ISuggestedActionCategorySet> GetSuggestedActionCategoriesAsync(ISuggestedActionCategorySet requestedActionCategories, SnapshotSpan range, CancellationToken cancellationToken) { if (_workspaceStatusService != null && !await _workspaceStatusService.IsFullyLoadedAsync(cancellationToken).ConfigureAwait(false)) { // never show light bulb if solution is not fully loaded yet return(null); } var provider = _owner; using (var asyncToken = _owner.OperationListener.BeginAsyncOperation(nameof(GetSuggestedActionCategoriesAsync))) { var document = range.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return(null); } using (var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)) { var linkedToken = linkedTokenSource.Token; var errorTask = Task.Run( () => GetFixLevelAsync(provider, document, range, linkedToken), linkedToken); var selection = await GetSpanAsync(range, linkedToken).ConfigureAwait(false); var refactoringTask = SpecializedTasks.Default <string>(); if (selection != null && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { refactoringTask = Task.Run( () => TryGetRefactoringSuggestedActionCategoryAsync(provider, document, selection, linkedToken), linkedToken); } // If we happen to get the result of the error task before the refactoring task, // and that result is non-null, we can just cancel the refactoring task. var result = await errorTask.ConfigureAwait(false) ?? await refactoringTask.ConfigureAwait(false); linkedTokenSource.Cancel(); return(result == null ? null : _suggestedActionCategoryRegistry.CreateSuggestedActionCategorySet(result)); } } }
protected override Task <IEnumerable <SymbolDisplayPart> > GetInitializerSourcePartsAsync( ISymbol symbol) { // Actually check for C# symbol types here. if (symbol is IParameterSymbol) { return(GetInitializerSourcePartsAsync((IParameterSymbol)symbol)); } else if (symbol is ILocalSymbol) { return(GetInitializerSourcePartsAsync((ILocalSymbol)symbol)); } else if (symbol is IFieldSymbol) { return(GetInitializerSourcePartsAsync((IFieldSymbol)symbol)); } return(SpecializedTasks.Default <IEnumerable <SymbolDisplayPart> >()); }
public Task <RemoteHostClient> GetRemoteHostClientAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); Task <RemoteHostClient> instance; lock (_gate) { instance = _instanceTask; } if (instance == null) { // service is in shutdown mode or not enabled return(SpecializedTasks.Default <RemoteHostClient>()); } return(instance); }
protected override Task <SyntaxNode> GetNewRoot( SyntaxNode root, SyntaxNode oldNode, SemanticModel semanticModel, Diagnostic diagnostic, Document document, CancellationToken cancellationToken) { var expression = oldNode as ExpressionSyntax; if (expression == null) { return(SpecializedTasks.Default <SyntaxNode>()); } switch (diagnostic.Id) { case CS4014: return(Task.FromResult(root.ReplaceNode(oldNode, ConvertToAwaitExpression(expression)))); case CS4016: if (!DoesExpressionReturnTask(expression, semanticModel)) { return(SpecializedTasks.Default <SyntaxNode>()); } return(Task.FromResult(root.ReplaceNode(oldNode, ConvertToAwaitExpression(expression)))); case CS0029: if (!DoesExpressionReturnGenericTaskWhoseArgumentsMatchLeftSide(expression, semanticModel, document.Project, cancellationToken)) { return(SpecializedTasks.Default <SyntaxNode>()); } return(Task.FromResult(root.ReplaceNode(oldNode, ConvertToAwaitExpression(expression)))); default: return(SpecializedTasks.Default <SyntaxNode>()); } }