public static CompletionItem Create( string displayText, string displayTextSuffix, CompletionItemRules rules, FSharpGlyph?glyph = null, ImmutableArray <SymbolDisplayPart> description = default, string sortText = null, string filterText = null, bool showsWarningIcon = false, ImmutableDictionary <string, string> properties = null, ImmutableArray <string> tags = default, string inlineDescription = null ) { var roslynGlyph = glyph.HasValue ? FSharpGlyphHelpers.ConvertTo(glyph.Value) : (Glyph?)null; return(CommonCompletionItem.Create( displayText, displayTextSuffix, rules, roslynGlyph, description, sortText, filterText, showsWarningIcon, properties, tags, inlineDescription )); }
// internal for testing internal ImmutableArray <CompletionItem> GetItems(string directoryPath, CancellationToken cancellationToken) { var result = ArrayBuilder <CompletionItem> .GetInstance(); var comma = directoryPath.IndexOf(','); if (comma >= 0) { var partialName = directoryPath.Substring(0, comma); foreach (var identity in GetAssemblyIdentities(partialName)) { result.Add(CommonCompletionItem.Create(identity.GetDisplayName(), glyph: Glyph.Assembly, rules: _itemRules)); } } else { foreach (var displayName in s_lazyAssemblySimpleNames.Value) { cancellationToken.ThrowIfCancellationRequested(); result.Add(CommonCompletionItem.Create(displayName, glyph: Glyph.Assembly, rules: _itemRules)); } } return(result.ToImmutableAndFree()); }
private CompletionItem CreateNuGetRoot() => CommonCompletionItem.Create( displayText: NuGetPrefix, displayTextSuffix: "", rules: s_rules, glyph: Microsoft.CodeAnalysis.Glyph.NuGet, sortText: "");
private async Task AddAssemblyCompletionItemsAsync(CompletionContext context, CancellationToken cancellationToken) { var currentProject = context.Document.Project; var allInternalsVisibleToAttributesOfProject = await GetAllInternalsVisibleToAssemblyNamesOfProjectAsync(context, cancellationToken).ConfigureAwait(false); foreach (var project in context.Document.Project.Solution.Projects) { if (project == currentProject) { continue; } if (allInternalsVisibleToAttributesOfProject.Contains(project.AssemblyName)) { continue; } var projectGuid = project.Id.Id.ToString(); var completionItem = CommonCompletionItem.Create( displayText: project.AssemblyName, rules: CompletionItemRules.Default, glyph: project.GetGlyph(), properties: ImmutableDictionary.Create <string, string>().Add(ProjectGuidKey, projectGuid)); context.AddItem(completionItem); } }
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")))); } }
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 static CompletionItem CreateSymbolCompletion(Symbol symbol, SymbolMarkupToken nameSuffix = null) { var displayText = symbol.Name; var description = symbol.ToMarkup(); var descriptionTokens = description.Tokens; if (nameSuffix != null) { descriptionTokens = descriptionTokens.Add(nameSuffix); } if (!string.IsNullOrEmpty(symbol.Documentation)) { descriptionTokens = descriptionTokens.Add(new SymbolMarkupToken(SymbolMarkupKind.Whitespace, "\n")); descriptionTokens = descriptionTokens.Add(new SymbolMarkupToken(SymbolMarkupKind.PlainText, symbol.Documentation)); } var glyph = symbol.GetGlyph(); return(CommonCompletionItem.Create( displayText, CompletionItemRules.Default, glyph, descriptionTokens)); }
private async Task <IEnumerable <CompletionItem> > GetSnippetCompletionItemsAsync( Workspace workspace, SemanticModel semanticModel, bool isPreProcessorContext, bool isTupleContext, CancellationToken cancellationToken) { var service = _snippetInfoService ?? workspace.Services.GetLanguageServices(semanticModel.Language).GetService <ISnippetInfoService>(); if (service == null) { return(SpecializedCollections.EmptyEnumerable <CompletionItem>()); } var snippets = service.GetSnippetsIfAvailable(); if (isPreProcessorContext) { snippets = snippets.Where(snippet => snippet.Shortcut != null && snippet.Shortcut.StartsWith("#", StringComparison.Ordinal)); } var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false); return(snippets.Select(snippet => { var rules = isTupleContext ? s_tupleRules : CompletionItemRules.Default; rules = rules.WithFormatOnCommit(service.ShouldFormatSnippet(snippet)); return CommonCompletionItem.Create( displayText: isPreProcessorContext?snippet.Shortcut.Substring(1) : snippet.Shortcut, displayTextSuffix: "", sortText: isPreProcessorContext ? snippet.Shortcut.Substring(1) : snippet.Shortcut, description: (snippet.Title + Environment.NewLine + snippet.Description).ToSymbolDisplayParts(), glyph: Glyph.Snippet, rules: rules); }).ToImmutableArray()); }
public static CompletionItem CreateCommonCompletionItem( string displayText, string displayTextSuffix, CompletionItemRules rules, PythiaGlyph?glyph, ImmutableArray <SymbolDisplayPart> description, string sortText, string filterText, bool showsWarningIcon = false, ImmutableDictionary <string, string>?properties = null, ImmutableArray <string> tags = default, string?inlineDescription = null ) => CommonCompletionItem.Create( displayText, displayTextSuffix, rules, (Glyph?)glyph, description, sortText, filterText, showsWarningIcon, properties, tags, inlineDescription );
public override async Task ProvideCompletionsAsync(CompletionContext context) { var originatingDocument = context.Document; if (originatingDocument.SourceCodeKind != SourceCodeKind.Regular) { return; } var cancellationToken = context.CancellationToken; var position = context.Position; var semanticModel = await originatingDocument.ReuseExistingSpeculativeModelAsync(position, cancellationToken).ConfigureAwait(false); var service = originatingDocument.GetRequiredLanguageService <ISyntaxContextService>(); var solution = originatingDocument.Project.Solution; var syntaxContext = service.CreateContext(solution.Workspace, semanticModel, position, cancellationToken); if (!syntaxContext.IsPreProcessorExpressionContext) { return; } foreach (var name in s_directivesName) { context.AddItem(CommonCompletionItem.Create( name, displayTextSuffix: "", CompletionItemRules.Default, glyph: Microsoft.CodeAnalysis.Glyph.Keyword, sortText: "_0_" + name)); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; // the provider might be invoked in non-interactive context: var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); if (Workspace.TryGetWorkspace(sourceText.Container, out var ws)) { if (ws is InteractiveWorkspace workspace) { var window = workspace.Window; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (await ShouldDisplayCommandCompletionsAsync(tree, position, cancellationToken).ConfigureAwait(false)) { var commands = window.GetInteractiveCommands(); if (commands != null) { foreach (var command in commands.GetCommands()) { foreach (var commandName in command.Names) { var completion = GetCompletionString(commandName); context.AddItem(CommonCompletionItem.Create( completion, displayTextSuffix: "", CompletionItemRules.Default, description: command.Description.ToSymbolDisplayParts(), glyph: Glyph.Intrinsic)); } } } } } } }
private async Task <IEnumerable <CompletionItem> > GetSnippetCompletionItemsAsync(Workspace workspace, SemanticModel semanticModel, int position, TextSpan itemSpan, bool isPreProcessorContext, CancellationToken cancellationToken) { var service = _snippetInfoService ?? workspace.Services.GetLanguageServices(semanticModel.Language).GetService <ISnippetInfoService>(); if (service == null) { return(SpecializedCollections.EmptyEnumerable <CompletionItem>()); } var snippets = service.GetSnippetsIfAvailable(); if (isPreProcessorContext) { snippets = snippets.Where(snippet => snippet.Shortcut.StartsWith("#", StringComparison.Ordinal)); } var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false); return(snippets.Select(snippet => CommonCompletionItem.Create( displayText: isPreProcessorContext?snippet.Shortcut.Substring(1) : snippet.Shortcut, sortText: isPreProcessorContext ? snippet.Shortcut.Substring(1) : snippet.Shortcut, description: (snippet.Title + Environment.NewLine + snippet.Description).ToSymbolDisplayParts(), span: itemSpan, glyph: Glyph.Snippet, shouldFormatOnCommit: service.ShouldFormatSnippet(snippet))).ToList()); }
protected CompletionItem CreateSuggestionModeItem(string displayText, string description) { return(CommonCompletionItem.Create( displayText: displayText ?? string.Empty, description: description != null ? description.ToSymbolDisplayParts() : default(ImmutableArray <SymbolDisplayPart>), rules: s_rules)); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var showSpeculativeT = await document.IsValidContextForDocumentOrLinkedDocumentsAsync( (doc, ct) => ShouldShowSpeculativeTCompletionItemAsync(doc, position, ct), cancellationToken).ConfigureAwait(false); if (showSpeculativeT) { var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); const string T = nameof(T); context.AddItem(CommonCompletionItem.Create( T, displayTextSuffix: "", CompletionItemRules.Default, glyph: Glyph.TypeParameter)); } } 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 semanticModel = await document.ReuseExistingSpeculativeModelAsync(position, cancellationToken).ConfigureAwait(false); var workspace = document.Project.Solution.Workspace; var syntaxContext = CSharpSyntaxContext.CreateContext(workspace, semanticModel, position, cancellationToken); if (!syntaxContext.IsAwaitKeywordContext(position)) { return; } var method = syntaxContext.TargetToken.GetAncestor(node => node.IsAsyncSupportingFunctionSyntax()); var shouldMakeContainerAsync = method is not null && !method.GetModifiers().Any(SyntaxKind.AsyncKeyword); var completionItem = CommonCompletionItem.Create( displayText: SyntaxFacts.GetText(SyntaxKind.AwaitKeyword), displayTextSuffix: "", rules: CompletionItemRules.Default, Glyph.Keyword, description: RecommendedKeyword.CreateDisplayParts(SyntaxFacts.GetText(SyntaxKind.AwaitKeyword), string.Empty), inlineDescription: shouldMakeContainerAsync ? CSharpFeaturesResources.Make_container_async : null, isComplexTextEdit: shouldMakeContainerAsync); context.AddItem(completionItem); }
private CompletionItem CreateLogicalDriveItem(string drive) => CommonCompletionItem.Create( drive, "", glyph: _folderGlyph, description: drive.ToSymbolDisplayParts(), rules: _itemRules);
private CompletionItem CreateFileSystemEntryItem(string fullPath, bool isDirectory) => CommonCompletionItem.Create( PathUtilities.GetFileName(fullPath), "", glyph: isDirectory ? _folderGlyph : _fileGlyph, description: fullPath.ToSymbolDisplayParts(), rules: _itemRules);
private CompletionItem CreateUnixRoot() => CommonCompletionItem.Create( "/", "", glyph: _folderGlyph, description: "/".ToSymbolDisplayParts(), rules: _itemRules);
private CompletionItem CreateNetworkRoot() => CommonCompletionItem.Create( "\\\\", "", glyph: null, description: "\\\\".ToSymbolDisplayParts(), rules: _itemRules);
private CompletionItem CreateCompletion(FileSystemInfo child) { return(CommonCompletionItem.Create( child.Name, glyph: child is DirectoryInfo ? _folderGlyph : _fileGlyph, description: child.FullName.ToSymbolDisplayParts(), rules: _itemRules)); }
private IEnumerable <CompletionItem> GetLogicalDrives() { // First, we may have a filename, so let's include all drives return(from d in _lazyGetDrives.Value where d.Length > 0 && (d.Last() == Path.DirectorySeparatorChar || d.Last() == Path.AltDirectorySeparatorChar) let text = d.Substring(0, d.Length - 1) select CommonCompletionItem.Create(text, glyph : _folderGlyph, rules : _itemRules)); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { try { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (tree.IsInNonUserCode(position, cancellationToken)) { return; } var targetToken = tree .FindTokenOnLeftOfPosition(position, cancellationToken) .GetPreviousTokenIfTouchingWord(position); if (!targetToken.IsKind(SyntaxKind.AliasKeyword) && !(targetToken.IsKind(SyntaxKind.IdentifierToken) && targetToken.HasMatchingText(SyntaxKind.AliasKeyword))) { return; } if (targetToken.Parent.IsKind(SyntaxKind.ExternAliasDirective) || (targetToken.Parent.IsKind(SyntaxKind.IdentifierName) && targetToken.Parent.IsParentKind(SyntaxKind.IncompleteMember))) { var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); var aliases = compilation.ExternalReferences.SelectMany(r => r.Properties.Aliases).ToSet(); if (aliases.Any()) { var root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false); var usedAliases = root.ChildNodes().OfType <ExternAliasDirectiveSyntax>() .Where(e => !e.Identifier.IsMissing) .Select(e => e.Identifier.ValueText); aliases.RemoveRange(usedAliases); aliases.Remove(MetadataReferenceProperties.GlobalAlias); var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); foreach (var alias in aliases) { context.AddItem(CommonCompletionItem.Create( alias, displayTextSuffix: "", CompletionItemRules.Default, glyph: Glyph.Namespace)); } } } } catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e)) { // nop } }
protected override CompletionItem CreateItem(RecommendedKeyword keyword, TextSpan span) { return(CommonCompletionItem.Create( displayText: keyword.Keyword, span: span, description: keyword.DescriptionFactory(CancellationToken.None), glyph: Glyph.Keyword, shouldFormatOnCommit: keyword.ShouldFormatOnCommit)); }
CompletionItem CreateCompletionItem(string name, Glyph glyph, string sortText) { return(CommonCompletionItem.Create( name, CompletionItemRules.Default, glyph: glyph, sortText: sortText, description: CSharpFeaturesResources.Suggested_name.ToSymbolDisplayParts())); }
protected virtual CompletionItem CreateItem(RecommendedKeyword keyword, TContext context) { return(CommonCompletionItem.Create( displayText: keyword.Keyword, rules: s_keywordRules.WithMatchPriority(keyword.MatchPriority), description: keyword.DescriptionFactory(CancellationToken.None), glyph: Glyph.Keyword, tags: s_Tags)); }
protected virtual CompletionItem CreateItem(RecommendedKeyword keyword) { return(CommonCompletionItem.Create( displayText: keyword.Keyword, description: keyword.DescriptionFactory(CancellationToken.None), glyph: Glyph.Keyword, tags: s_Tags, matchPriority: keyword.MatchPriority)); }
protected virtual CompletionItem CreateItem(RecommendedKeyword keyword, TextSpan span) { return(CommonCompletionItem.Create( displayText: keyword.Keyword, span: span, description: keyword.DescriptionFactory(CancellationToken.None), glyph: Glyph.Keyword, tags: s_Tags, preselect: keyword.ShouldPreselect)); }
public sealed override async Task ProvideCompletionsAsync(CompletionContext context) { var cancellationToken = context.CancellationToken; var originatingDocument = context.Document; var position = context.Position; var semanticModel = await originatingDocument .ReuseExistingSpeculativeModelAsync(position, cancellationToken) .ConfigureAwait(false); var service = originatingDocument.GetRequiredLanguageService <ISyntaxContextService>(); var solution = originatingDocument.Project.Solution; var syntaxContext = service.CreateContext( solution.Workspace, semanticModel, position, cancellationToken ); if (!syntaxContext.IsPreProcessorExpressionContext) { return; } // Walk all the projects this document is linked in so that we get the full set of preprocessor symbols // defined across all of them. var syntaxFacts = originatingDocument.GetRequiredLanguageService <ISyntaxFactsService>(); var preprocessorNames = new HashSet <string>(syntaxFacts.StringComparer); foreach (var documentId in solution.GetRelatedDocumentIds(originatingDocument.Id)) { var document = solution.GetRequiredDocument(documentId); var currentSyntaxTree = await document .GetRequiredSyntaxTreeAsync(cancellationToken) .ConfigureAwait(false); preprocessorNames.AddRange(currentSyntaxTree.Options.PreprocessorSymbolNames); } // Keep all the preprocessor symbol names together. We don't want to intermingle them with any keywords we // include (like `true/false`) foreach (var name in preprocessorNames.OrderBy(a => a)) { context.AddItem( CommonCompletionItem.Create( name, displayTextSuffix: "", CompletionItemRules.Default, glyph: Glyph.Keyword, sortText: "_0_" + name ) ); } }
public void FullReferenceIdentityDescription() { var code = "System"; var completions = GetItems(code); var systemsColl = from completion in completions where completion.DisplayText == "System" select completion; Assert.True(systemsColl.Any( completion => CommonCompletionItem.GetDescription(completion).Text == typeof(System.Diagnostics.Process).Assembly.FullName)); }
protected override CompletionItem CreateItem(RecommendedKeyword keyword, CSharpSyntaxContext context) { var rules = context.IsPossibleTupleContext ? s_tupleRules : CompletionItemRules.Default; return(CommonCompletionItem.Create( displayText: keyword.Keyword, description: keyword.DescriptionFactory(CancellationToken.None), glyph: Glyph.Keyword, rules: rules.WithMatchPriority(keyword.MatchPriority) .WithFormatOnCommit(keyword.ShouldFormatOnCommit))); }