public override async Task ProvideCompletionsAsync(CompletionContext context) { if (await IsWatchWindowAsync(context).ConfigureAwait(false)) { // Completions are not usable in watch window return; } var syntaxContext = await SyntaxContext.CreateAsync(context.Document, context.Position, context.CancellationToken) .ConfigureAwait(false); var applicableTypeProviders = typeCompletionProviders .Where(p => p.IsApplicable(syntaxContext, Options)) .ToArray(); if (applicableTypeProviders.Length > 0) { var typeCompletions = GetAllTypes(syntaxContext, Options) .SelectMany(type => applicableTypeProviders .Select(provider => provider.GetCompletionItemsForType(type, syntaxContext, Options))) .Where(enumerable => enumerable != null) .SelectMany(enumerable => enumerable); context.AddItems(typeCompletions); } var simpleCompletions = simpleCompletionProviders .Where(p => p.IsApplicable(syntaxContext, Options)) .Select(provider => provider.GetCompletionItems(syntaxContext, Options)) .Where(enumerable => enumerable != null) .SelectMany(enumerable => enumerable); context.AddItems(simpleCompletions); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (syntaxTree.IsInNonUserCode(position, cancellationToken)) { return; } var token = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken); token = token.GetPreviousTokenIfTouchingWord(position); if (!token.IsKind(SyntaxKind.OpenParenToken, SyntaxKind.CommaToken)) { return; } if (!(token.Parent.Parent is AttributeSyntax attributeSyntax) || !(token.Parent is AttributeArgumentListSyntax attributeArgumentList)) { return; } if (IsAfterNameColonArgument(token) || IsAfterNameEqualsArgument(token)) { context.IsExclusive = true; } // We actually want to collect two sets of named parameters to present the user. The // normal named parameters that come from the attribute constructors. These will be // presented like "goo:". And also the named parameters that come from the writable // fields/properties in the attribute. These will be presented like "bar =". var existingNamedParameters = GetExistingNamedParameters(attributeArgumentList, position); var workspace = document.Project.Solution.Workspace; var semanticModel = await document.GetSemanticModelForNodeAsync(attributeSyntax, cancellationToken).ConfigureAwait(false); var nameColonItems = await GetNameColonItemsAsync(context, semanticModel, token, attributeSyntax, existingNamedParameters).ConfigureAwait(false); var nameEqualsItems = await GetNameEqualsItemsAsync(context, semanticModel, token, attributeSyntax, existingNamedParameters).ConfigureAwait(false); context.AddItems(nameEqualsItems); // If we're after a name= parameter, then we only want to show name= parameters. // Otherwise, show name: parameters too. if (!IsAfterNameEqualsArgument(token)) { context.AddItems(nameColonItems); } } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
protected override async Task ProvideCompletionsAsync(CompletionContext context, string pathThroughLastSlash) { var resolver = context.Document.Project.CompilationOptions.MetadataReferenceResolver as RuntimeMetadataReferenceResolver; if (resolver != null && pathThroughLastSlash.IndexOfAny(s_pathIndicators) < 0) { foreach (var(name, path) in resolver.TrustedPlatformAssemblies) { context.AddItem(CommonCompletionItem.Create(name, displayTextSuffix: "", glyph: Glyph.Assembly, rules: s_rules)); context.AddItem(CommonCompletionItem.Create(PathUtilities.GetFileName(path, includeExtension: true), displayTextSuffix: "", glyph: Glyph.Assembly, rules: s_rules)); } if (resolver.GacFileResolver is object) { var gacHelper = new GlobalAssemblyCacheCompletionHelper(s_rules); context.AddItems(await gacHelper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } } if (pathThroughLastSlash.IndexOf(',') < 0) { var helper = GetFileSystemCompletionHelper(context.Document, Glyph.Assembly, RuntimeMetadataReferenceResolver.AssemblyExtensions, s_rules); context.AddItems(await helper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } }
private async Task ProvideNuGetCompletionsAsync(CompletionContext context, string packageIdAndVersion) { var(id, version) = ParseNuGetReference(packageIdAndVersion); var packages = await Task.Run(() => _nuGetCompletionProvider.SearchPackagesAsync(id, exactMatch: version != null, context.CancellationToken), context.CancellationToken).ConfigureAwait(false); if (version != null) { if (packages.Count > 0) { var package = packages[0]; var versions = package.Versions; if (!string.IsNullOrWhiteSpace(version)) { versions = versions.Where(v => v.StartsWith(version, StringComparison.InvariantCultureIgnoreCase)); } context.AddItems(versions.Select((v, i) => CommonCompletionItem.Create( v, s_rules, Microsoft.CodeAnalysis.Glyph.NuGet, sortText: i.ToString("0000")))); } } else { context.AddItems(packages.Select((p, i) => CommonCompletionItem.Create( NuGetPrefix + p.Id + "/", s_rules, Microsoft.CodeAnalysis.Glyph.NuGet, sortText: i.ToString("0000")))); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var span = context.DefaultItemSpan; var options = context.Options; var cancellationToken = context.CancellationToken; // If we were triggered by typing a character, then do a semantic check to make sure // we're still applicable. If not, then return immediately. if (context.Trigger.Kind == CompletionTriggerKind.Insertion) { var isSemanticTriggerCharacter = await IsSemanticTriggerCharacterAsync(document, position - 1, cancellationToken).ConfigureAwait(false); if (!isSemanticTriggerCharacter) { return; } } context.IsExclusive = IsExclusive(); using (Logger.LogBlock(FunctionId.Completion_SymbolCompletionProvider_GetItemsWorker, cancellationToken)) { var regularItems = await GetItemsWorkerAsync(document, position, span, options, preselect : false, cancellationToken : cancellationToken).ConfigureAwait(false); context.AddItems(regularItems); var preselectedItems = await GetItemsWorkerAsync(document, position, span, options, preselect : true, cancellationToken : cancellationToken).ConfigureAwait(false); context.AddItems(preselectedItems); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); // first try to get the #r string literal token. If we couldn't, then we're not in a #r // reference directive and we immediately bail. SyntaxToken stringLiteral; if (!TryGetStringLiteralToken(tree, position, out stringLiteral, cancellationToken)) { return; } var textChangeSpan = GetTextChangeSpan(stringLiteral, position); var gacHelper = new GlobalAssemblyCacheCompletionHelper(textChangeSpan, _rules); var referenceResolver = document.Project.CompilationOptions.MetadataReferenceResolver; // TODO: https://github.com/dotnet/roslyn/issues/5263 // Avoid dependency on a specific resolvers. // The search paths should be provided by specialized workspaces: // - InteractiveWorkspace for interactive window // - ScriptWorkspace for loose .csx files (we don't have such workspace today) ImmutableArray <string> searchPaths; RuntimeMetadataReferenceResolver rtResolver; WorkspaceMetadataFileReferenceResolver workspaceResolver; if ((rtResolver = referenceResolver as RuntimeMetadataReferenceResolver) != null) { searchPaths = rtResolver.PathResolver.SearchPaths; } else if ((workspaceResolver = referenceResolver as WorkspaceMetadataFileReferenceResolver) != null) { searchPaths = workspaceResolver.PathResolver.SearchPaths; } else { return; } var fileSystemHelper = new FileSystemCompletionHelper( this, textChangeSpan, new CurrentWorkingDirectoryDiscoveryService(Directory.GetCurrentDirectory()), Microsoft.CodeAnalysis.Glyph.OpenFolder, Microsoft.CodeAnalysis.Glyph.Assembly, searchPaths, new[] { ".dll", ".exe" }, path => path.Contains(","), _rules); var pathThroughLastSlash = GetPathThroughLastSlash(stringLiteral, position); var documentPath = document.Project.IsSubmission ? null : document.FilePath; context.AddItems(gacHelper.GetItems(pathThroughLastSlash, documentPath)); context.AddItems(fileSystemHelper.GetItems(pathThroughLastSlash, documentPath)); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { if (Options == null) { // Package not loaded yet (e.g. no solution opened) return; } if (await IsWatchWindowAsync(context).ConfigureAwait(false)) { // Completions are not usable in watch window return; } if (IsRazorView(context)) { // Completions are not usable in cshtml-Razor Views. Insertion of Namespaces doesn't work there. return; } var syntaxContext = await SyntaxContext.CreateAsync(context.Document, context.Position, context.CancellationToken) .ConfigureAwait(false); var applicableTypeProviders = typeCompletionProviders .Where(p => p.IsApplicable(syntaxContext, Options)) .ToArray(); if (applicableTypeProviders.Length > 0) { var typeCompletions = SymbolNavigator.GetAllTypes(syntaxContext, Options) .SelectMany(type => applicableTypeProviders .Select(provider => provider.GetCompletionItemsForType(type, syntaxContext, Options))) .Where(enumerable => enumerable != null) .SelectMany(enumerable => enumerable); context.AddItems(typeCompletions); } var simpleCompletions = simpleCompletionProviders .Where(p => p.IsApplicable(syntaxContext, Options)) .Select(provider => provider.GetCompletionItems(syntaxContext, Options)) .Where(enumerable => enumerable != null) .SelectMany(enumerable => enumerable); context.AddItems(simpleCompletions); // If Completion was triggered by this provider - use suggestion mode if (_triggeredByUs && context.SuggestionModeItem == null) { context.SuggestionModeItem = CompletionItem.Create(""); } } finally { _triggeredByUs = false; } }
public override async Task ProvideCompletionsAsync(CompletionContext completionContext) { try { var document = completionContext.Document; var position = completionContext.Position; var options = completionContext.Options; var cancellationToken = completionContext.CancellationToken; // If we were triggered by typing a character, then do a semantic check to make sure // we're still applicable. If not, then return immediately. if (completionContext.Trigger.Kind == CompletionTriggerKind.Insertion) { var isSemanticTriggerCharacter = await IsSemanticTriggerCharacterAsync(document, position - 1, cancellationToken).ConfigureAwait(false); if (!isSemanticTriggerCharacter) { return; } } completionContext.IsExclusive = IsExclusive(); using (Logger.LogBlock(FunctionId.Completion_SymbolCompletionProvider_GetItemsWorker, cancellationToken)) using (var telemetryCounter = new TelemetryCounter(ShouldCollectTelemetryForTargetTypeCompletion && IsTargetTypeCompletionFilterExperimentEnabled(document.Project.Solution.Workspace))) { var syntaxContext = await GetOrCreateContextAsync(document, position, cancellationToken).ConfigureAwait(false); var inferredTypes = new Lazy <ImmutableArray <ITypeSymbol> >(() => { var typeInferenceService = document.GetLanguageService <ITypeInferenceService>(); return(typeInferenceService.InferTypes(syntaxContext.SemanticModel, position, cancellationToken)); }); var regularItems = await GetItemsWorkerAsync(completionContext, syntaxContext, document, position, inferredTypes, options, preselect : false, telemetryCounter, cancellationToken).ConfigureAwait(false); completionContext.AddItems(regularItems); // We may or may not want to provide preselected items based on context. For example, C# avoids provide providing preselected items when // triggered via text insertion in an argument list. if (await ShouldProvidePreselectedItemsAsync(completionContext, syntaxContext, document, position, inferredTypes, options).ConfigureAwait(false)) { var preselectedItems = await GetItemsWorkerAsync(completionContext, syntaxContext, document, position, inferredTypes, options, preselect : true, telemetryCounter, cancellationToken).ConfigureAwait(false); completionContext.AddItems(preselectedItems); } } } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
protected override async Task ProvideCompletionsAsync(CompletionContext context, string pathThroughLastSlash) { if (GacFileResolver.IsAvailable && pathThroughLastSlash.IndexOfAny(s_pathIndicators) < 0) { var gacHelper = new GlobalAssemblyCacheCompletionHelper(s_rules); context.AddItems(await gacHelper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } if (pathThroughLastSlash.IndexOf(',') < 0) { var helper = GetFileSystemCompletionHelper(context.Document, Glyph.Assembly, ImmutableArray.Create(".dll", ".exe"), s_rules); context.AddItems(await helper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } }
protected override async Task ProvideCompletionsAsync(CompletionContext context, string pathThroughLastSlash) { if (GacFileResolver.IsAvailable && pathThroughLastSlash.IndexOfAny(s_pathIndicators) < 0) { var gacHelper = new GlobalAssemblyCacheCompletionHelper(s_rules); context.AddItems(await gacHelper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } if (pathThroughLastSlash.IndexOf(',') < 0) { var text = await context.Document.GetTextAsync(context.CancellationToken).ConfigureAwait(false); var fileSystemHelper = GetFileSystemCompletionHelper(text, context.Document); context.AddItems(await fileSystemHelper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); } }
public async sealed override Task ProvideCompletionsAsync(CompletionContext completionContext) { try { var document = completionContext.Document; var position = completionContext.Position; var cancellationToken = completionContext.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var node = GetPartialTypeSyntaxNode(tree, position, cancellationToken); if (node != null) { var semanticModel = await document.GetSemanticModelForNodeAsync(node, cancellationToken).ConfigureAwait(false); var syntaxContext = await CreateSyntaxContextAsync(document, semanticModel, position, cancellationToken).ConfigureAwait(false); if (semanticModel.GetDeclaredSymbol(node, cancellationToken) is INamedTypeSymbol declaredSymbol) { var symbols = LookupCandidateSymbols(syntaxContext, declaredSymbol, cancellationToken); var items = symbols?.Select(s => CreateCompletionItem(s, syntaxContext)); if (items != null) { completionContext.AddItems(items); } } } } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
public async sealed override Task ProvideCompletionsAsync(CompletionContext completionContext) { var document = completionContext.Document; var position = completionContext.Position; var cancellationToken = completionContext.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var node = GetPartialTypeSyntaxNode(tree, position, cancellationToken); if (node != null) { var semanticModel = await document.GetSemanticModelForNodeAsync(node, cancellationToken).ConfigureAwait(false); var syntaxContext = await CreateSyntaxContextAsync(document, semanticModel, position, cancellationToken).ConfigureAwait(false); var declaredSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken) as INamedTypeSymbol; if (declaredSymbol != null) { var symbols = LookupCandidateSymbols(syntaxContext, declaredSymbol, cancellationToken); var items = symbols?.Select(s => CreateCompletionItem(s, syntaxContext)); if (items != null) { completionContext.AddItems(items); } } } }
protected async override Task AddCompletionItemsAsync( CompletionContext completionContext, SyntaxContext syntaxContext, HashSet <string> namespaceInScope, bool isExpandedCompletion, CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.Completion_ExtensionMethodImportCompletionProvider_GetCompletionItemsAsync, cancellationToken)) { var syntaxFacts = completionContext.Document.GetRequiredLanguageService <ISyntaxFactsService>(); if (TryGetReceiverTypeSymbol(syntaxContext, syntaxFacts, cancellationToken, out var receiverTypeSymbol)) { var items = await ExtensionMethodImportCompletionHelper.GetUnimportedExtensionMethodsAsync( completionContext.Document, completionContext.Position, receiverTypeSymbol, namespaceInScope, forceIndexCreation : isExpandedCompletion, cancellationToken).ConfigureAwait(false); completionContext.AddItems(items.Select(i => Convert(i))); } else { // If we can't get a valid receiver type, then we don't show expander as available. // We need to set this explicitly here because we didn't do the (more expensive) symbol check inside // `ShouldProvideCompletion` method above, which is intended for quick syntax based check. completionContext.ExpandItemsAvailable = false; } } }
public async sealed override Task ProvideCompletionsAsync(CompletionContext completionContext) { var document = completionContext.Document; var position = completionContext.Position; var cancellationToken = completionContext.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var node = GetPartialTypeSyntaxNode(tree, position, cancellationToken); if (node != null) { var semanticModel = await document.GetSemanticModelForNodeAsync(node, cancellationToken).ConfigureAwait(false); var syntaxContext = await CreateSyntaxContextAsync(document, semanticModel, position, cancellationToken).ConfigureAwait(false); var declaredSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken) as INamedTypeSymbol; if (declaredSymbol != null) { var symbols = LookupCandidateSymbols(syntaxContext, declaredSymbol, cancellationToken); var items = symbols?.Select(s => CreateCompletionItem(s, syntaxContext)); if (items != null) { completionContext.AddItems(items); } } } }
public sealed override async Task ProvideCompletionsAsync(CompletionContext completionContext) { try { var document = completionContext.Document; var position = completionContext.Position; var cancellationToken = completionContext.CancellationToken; var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var node = GetPartialTypeSyntaxNode(tree, position, cancellationToken); if (node != null) { var semanticModel = await document.ReuseExistingSpeculativeModelAsync(node, cancellationToken).ConfigureAwait(false); if (semanticModel.GetDeclaredSymbol(node, cancellationToken) is INamedTypeSymbol declaredSymbol) { var syntaxContextService = document.GetRequiredLanguageService <ISyntaxContextService>(); var syntaxContext = (TSyntaxContext)syntaxContextService.CreateContext(document, semanticModel, position, cancellationToken); var symbols = LookupCandidateSymbols(syntaxContext, declaredSymbol, cancellationToken); var items = symbols?.Select(s => CreateCompletionItem(s, syntaxContext)); if (items != null) { completionContext.AddItems(items); } } } } catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e)) { // nop } }
private Task AddCompletionItems(CompletionContext context) { if (!_codeDocumentProvider.Value.TryGetFromDocument(context.Document, out var codeDocument)) { // A Razor code document has not yet been associated with the document. return(Task.CompletedTask); } var syntaxTree = codeDocument.GetSyntaxTree(); if (syntaxTree == null) { // No syntax tree has been computed for the current document. return(Task.CompletedTask); } if (!AtDirectiveCompletionPoint(syntaxTree, context)) { // Can't have a valid directive at the current location. return(Task.CompletedTask); } var completionItems = GetCompletionItems(syntaxTree); context.AddItems(completionItems); return(Task.CompletedTask); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var options = context.Options; var cancellationToken = context.CancellationToken; var(token, semanticModel, symbols) = await GetSymbolsAsync(document, position, options, cancellationToken).ConfigureAwait(false); if (symbols.Length == 0) { return; } context.IsExclusive = true; var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); var span = GetCompletionItemSpan(text, position); var hideAdvancedMembers = options.GetOption(CompletionOptions.HideAdvancedMembers, semanticModel.Language); var serializedOptions = ImmutableDictionary <string, string> .Empty.Add(HideAdvancedMembers, hideAdvancedMembers.ToString()); var items = CreateCompletionItems(document.Project.Solution.Workspace, semanticModel, symbols, token, span, position, serializedOptions); context.AddItems(items); } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); DeclarationModifiers modifiers; SyntaxToken token; if (!IsPartialMethodCompletionContext(tree, position, cancellationToken, out modifiers, out token)) { return; } var items = await CreatePartialItemsAsync( document, position, context.CompletionListSpan, modifiers, token, cancellationToken).ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var options = context.Options; var cancellationToken = context.CancellationToken; using (Logger.LogBlock(FunctionId.Completion_SnippetCompletionProvider_GetItemsWorker_CSharp, cancellationToken)) { // TODO (https://github.com/dotnet/roslyn/issues/5107): Enable in Interactive. var workspace = document.Project.Solution.Workspace; if (!workspace.CanApplyChange(ApplyChangesKind.ChangeDocument) || workspace.Kind == WorkspaceKind.Debugger || workspace.Kind == WorkspaceKind.Interactive) { return; } var snippetCompletionItems = await document.GetUnionItemsFromDocumentAndLinkedDocumentsAsync( UnionCompletionItemComparer.Instance, (d, c) => GetSnippetsForDocumentAsync(d, position, workspace, c), cancellationToken).ConfigureAwait(false); context.AddItems(snippetCompletionItems); } } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var text = await context.Document.GetTextAsync(context.CancellationToken).ConfigureAwait(false); var items = GetItems(text, context.Document, context.Position, context.Trigger, context.CancellationToken); context.AddItems(items); }
protected override async Task ProvideCompletionsAsync(CompletionContext context, string pathThroughLastSlash) { var text = await context.Document.GetTextAsync(context.CancellationToken).ConfigureAwait(false); var helper = GetFileSystemCompletionHelper(text, context.Document); context.AddItems(await helper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); }
protected override async Task AddCompletionItemsAsync( CompletionContext completionContext, SyntaxContext syntaxContext, HashSet <string> namespaceInScope, bool isExpandedCompletion, CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.Completion_ExtensionMethodImportCompletionProvider_GetCompletionItemsAsync, cancellationToken)) { var syntaxFacts = completionContext.Document.GetRequiredLanguageService <ISyntaxFactsService>(); if (TryGetReceiverTypeSymbol(syntaxContext, syntaxFacts, cancellationToken, out var receiverTypeSymbol)) { using var nestedTokenSource = new CancellationTokenSource(); using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(nestedTokenSource.Token, cancellationToken); var inferredTypes = completionContext.CompletionOptions.TargetTypedCompletionFilter ? syntaxContext.InferredTypes : ImmutableArray <ITypeSymbol> .Empty; var getItemsTask = Task.Run(() => ExtensionMethodImportCompletionHelper.GetUnimportedExtensionMethodsAsync( completionContext.Document, completionContext.Position, receiverTypeSymbol, namespaceInScope, inferredTypes, forceIndexCreation: isExpandedCompletion, hideAdvancedMembers: completionContext.CompletionOptions.HideAdvancedMembers, linkedTokenSource.Token)); var timeoutInMilliseconds = completionContext.CompletionOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion; // Timebox is enabled if timeout value is >= 0 and we are not triggered via expander if (timeoutInMilliseconds >= 0 && !isExpandedCompletion) { // timeout == 0 means immediate timeout (for testing purpose) if (timeoutInMilliseconds == 0 || await Task.WhenAny(getItemsTask, Task.Delay(timeoutInMilliseconds, linkedTokenSource.Token)).ConfigureAwait(false) != getItemsTask) { nestedTokenSource.Cancel(); CompletionProvidersLogger.LogExtensionMethodCompletionTimeoutCount(); return; } } // Either the timebox is not enabled, so we need to wait until the operation for complete, // or there's no timeout, and we now have all completion items ready. var items = await getItemsTask.ConfigureAwait(false); var receiverTypeKey = SymbolKey.CreateString(receiverTypeSymbol, cancellationToken); completionContext.AddItems(items.Select(i => Convert(i, receiverTypeKey))); } else { // If we can't get a valid receiver type, then we don't show expander as available. // We need to set this explicitly here because we didn't do the (more expensive) symbol check inside // `ShouldProvideCompletion` method above, which is intended for quick syntax based check. completionContext.ExpandItemsAvailable = false; } } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (!context.Document.SupportsSemanticModel) { return; } var model = await context.Document.GetSemanticModelAsync(); var tree = model.SyntaxTree; var node = GetCurrentLiteral(tree, context.Position); // if in string literal in method arguments if (node is LiteralExpressionSyntax && node.IsKind(SyntaxKind.StringLiteralExpression) && node.Parent is ArgumentSyntax && node.Parent.Parent is ArgumentListSyntax) { var memberReference = (node.Parent.Parent.Parent as InvocationExpressionSyntax)?.Expression as MemberAccessExpressionSyntax; if (memberReference != null) { // get possible methods var memberSymbol = model.GetSymbolInfo(memberReference); var methodName = memberSymbol.CandidateSymbols.Concat(new[] { memberSymbol.Symbol }).OfType <IMethodSymbol>().Select(GetFullName).First(); // it should be single method name, as the symbols are oveloads var typeSymbol = TryFindResultType(memberReference.Expression, model); if (typeSymbol != null) { if (methodName == typeof(Type).FullName + ".GetMethod") { context.AddItems(GetCompletionItems <IMethodSymbol>(typeSymbol, model, context.Position)); } if (methodName == typeof(Type).FullName + ".GetField") { context.AddItems(GetCompletionItems <IFieldSymbol>(typeSymbol, model, context.Position)); } if (methodName == typeof(Type).FullName + ".GetProperty") { context.AddItems(GetCompletionItems <IPropertySymbol>(typeSymbol, model, context.Position)); } if (methodName == typeof(Type).FullName + ".GetMembers") { context.AddItems(GetCompletionItems <ISymbol>(typeSymbol, model, context.Position)); } } } } }
/// <inheritdoc /> public override async Task ProvideCompletionsAsync(CompletionContext context) { var items = await GetItemsAsync(context.Document, context.Position, context.Trigger, context.CancellationToken).ConfigureAwait(false); if (items != null) { context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var state = await ItemGetter.CreateAsync(this, context.Document, context.Position, context.CancellationToken).ConfigureAwait(false); var items = await state.GetItemsAsync().ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var state = await ItemGetter.CreateAsync(this, context.Document, context.Position, context.CancellationToken).ConfigureAwait(false); var items = await state.GetItemsAsync().ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
protected override async Task ProvideCompletionsAsync(CompletionContext context, string pathThroughLastSlash) { var extension = Path.GetExtension(context.Document.FilePath); if (extension == null) { return; } var helper = GetFileSystemCompletionHelper(context.Document, Microsoft.CodeAnalysis.Glyph.CSharpFile, ImmutableArray.Create(extension), s_rules); context.AddItems(await helper.GetItemsAsync(pathThroughLastSlash, context.CancellationToken).ConfigureAwait(false)); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (!context.Options.GetOption(CompletionControllerOptions.ShowXmlDocCommentCompletion)) { return; } var items = await GetItemsWorkerAsync(context.Document, context.Position, context.DefaultItemSpan, context.Trigger, context.CancellationToken).ConfigureAwait(false); if (items != null) { context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var options = context.Options; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (!tree.IsEntirelyWithinCrefSyntax(position, cancellationToken)) { return; } var token = tree.FindTokenOnLeftOfPosition(position, cancellationToken, includeDocumentationComments: true) .GetPreviousTokenIfTouchingWord(position); // To get a Speculative SemanticModel (which is much faster), we need to // walk up to the node the DocumentationTrivia is attached to. var parentNode = token.Parent.FirstAncestorOrSelf <DocumentationCommentTriviaSyntax>()?.ParentTrivia.Token.Parent; _testSpeculativeNodeCallbackOpt?.Invoke(parentNode); if (parentNode == null) { return; } var semanticModel = await document.GetSemanticModelForNodeAsync( parentNode, cancellationToken).ConfigureAwait(false); var symbols = GetSymbols(token, semanticModel, cancellationToken); symbols = symbols.FilterToVisibleAndBrowsableSymbols(options.GetOption(CompletionOptions.HideAdvancedMembers, semanticModel.Language), semanticModel.Compilation); if (!symbols.Any()) { return; } context.IsExclusive = true; var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); var span = GetCompletionItemSpan(text, position); var items = CreateCompletionItems(document.Project.Solution.Workspace, semanticModel, symbols, token, span); context.AddItems(items); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (syntaxTree.IsInNonUserCode(position, cancellationToken)) { return; } var token = syntaxTree .FindTokenOnLeftOfPosition(position, cancellationToken) .GetPreviousTokenIfTouchingWord(position); if (!token.IsKind(SyntaxKind.OpenBracketToken, SyntaxKind.CommaToken)) { return; } if (token.Parent is not FunctionPointerUnmanagedCallingConventionListSyntax callingConventionList) { return; } var contextPosition = token.SpanStart; var semanticModel = await document.ReuseExistingSpeculativeModelAsync(callingConventionList, cancellationToken).ConfigureAwait(false); var completionItems = new HashSet <CompletionItem>(CompletionItemComparer.Instance); AddTypes(completionItems, contextPosition, semanticModel, cancellationToken); // Even if we didn't have types, there are four magic calling conventions recognized regardless. // We add these after doing the type lookup so if we had types we can show that instead foreach (var callingConvention in s_predefinedCallingConventions) { completionItems.Add(CompletionItem.Create(callingConvention, tags: GlyphTags.GetTags(Glyph.Keyword))); } context.AddItems(completionItems); } catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e)) { // nop } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { if (Options == null) { // Package not loaded yet (e.g. no solution opened) return; } if (await IsWatchWindowAsync(context).ConfigureAwait(false)) { // Completions are not usable in watch window return; } if (IsRazorView(context)) { // Completions are not usable in cshtml-Razor Views. Insertion of Namespaces doesn't work there. return; } var syntaxContext = await SyntaxContext.CreateAsync(context.Document, context.Position, context.CancellationToken) .ConfigureAwait(false); if (syntaxContext == null) { return; } var completionsTasks = completionProviders .Where(p => p.IsApplicable(syntaxContext, Options)) .Select(provider => provider.GetCompletionItemsAsync(syntaxContext, Options)); var completions = (await Task.WhenAll(completionsTasks).ConfigureAwait(false)).SelectMany(i => i); context.AddItems(completions); // If Completion was triggered by this provider - use suggestion mode if (_triggeredByUs && context.SuggestionModeItem == null) { context.SuggestionModeItem = CompletionItem.Create(""); } } finally { _triggeredByUs = false; } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (Options.EnableUnimportedSuggestions) { _symbolMapping = new Dictionary <string, ISymbol>(); var syntaxContext = await SyntaxContext.Create(context.Document, context.Position, context.CancellationToken) .ConfigureAwait(false); var symbols = GetSymbols(syntaxContext); var completionItemsToAdd = symbols .Select(symbol => CreateCompletionItemForSymbol(symbol, syntaxContext)) .ToList(); context.AddItems(completionItemsToAdd); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (!IsPartialMethodCompletionContext(tree, position, cancellationToken, out var modifiers, out var token)) { return; } var items = await CreatePartialItemsAsync( document, position, context.CompletionListSpan, modifiers, token, cancellationToken).ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var options = context.Options; var cancellationToken = context.CancellationToken; // If we were triggered by typing a character, then do a semantic check to make sure // we're still applicable. If not, then return immediately. if (context.Trigger.Kind == CompletionTriggerKind.Insertion) { var isSemanticTriggerCharacter = await IsSemanticTriggerCharacterAsync(document, position - 1, cancellationToken).ConfigureAwait(false); if (!isSemanticTriggerCharacter) { return; } } context.IsExclusive = IsExclusive(); using (Logger.LogBlock(FunctionId.Completion_SymbolCompletionProvider_GetItemsWorker, cancellationToken)) { var regularItems = await GetItemsWorkerAsync(document, position, options, preselect: false, cancellationToken: cancellationToken).ConfigureAwait(false); context.AddItems(regularItems); var preselectedItems = await GetItemsWorkerAsync(document, position, options, preselect: true, cancellationToken: cancellationToken).ConfigureAwait(false); context.AddItems(preselectedItems); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (!context.Options.GetOption(CompletionControllerOptions.ShowXmlDocCommentCompletion)) { return; } var items = await GetItemsWorkerAsync(context.Document, context.Position, context.DefaultItemSpan, context.Trigger, context.CancellationToken).ConfigureAwait(false); if (items != null) { context.AddItems(items); } }