protected override void CompleteDialogExtention() { base.CompleteDialogExtention(); CompletionOptions.Add(new XrmButtonViewModel("Option 1", () => ApplicationController.UserMessage("Dummy"), ApplicationController)); CompletionOptions.Add(new XrmButtonViewModel("option 2", () => ApplicationController.UserMessage("Dummy 2"), ApplicationController)); }
internal sealed override async Task <CompletionDescription> GetDescriptionWorkerAsync( Document document, CompletionItem item, CompletionOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken) { var description = await GetDescriptionAsync(item, document, displayOptions, cancellationToken).ConfigureAwait(false); return(UpdateDescription(description)); }
internal override CompletionRules GetRules(CompletionOptions options) { var enterRule = options.EnterKeyBehavior; var snippetRule = options.SnippetsBehavior; // Although EnterKeyBehavior is a per-language setting, the meaning of an unset setting (Default) differs between C# and VB // In C# the default means Never to maintain previous behavior if (enterRule == EnterKeyRule.Default) { enterRule = EnterKeyRule.Never; } if (snippetRule == SnippetsRule.Default) { snippetRule = SnippetsRule.AlwaysInclude; } // use interlocked + stored rules to reduce # of times this gets created when option is different than default var newRules = _latestRules.WithDefaultEnterKeyRule(enterRule) .WithSnippetsRule(snippetRule); Interlocked.Exchange(ref _latestRules, newRules); return(newRules); }
public CompletionListUpdater( IAsyncCompletionSession session, AsyncCompletionSessionDataSnapshot data, RecentItemsManager recentItemsManager, IGlobalOptionService globalOptions) { _session = session; _data = data; _recentItemsManager = recentItemsManager; _filterText = _session.ApplicableToSpan.GetText(_data.Snapshot); if (!_session.Properties.TryGetProperty(CompletionSource.HasSuggestionItemOptions, out bool hasSuggestedItemOptions)) { // This is the scenario when the session is created out of Roslyn, in some other provider, e.g. in Debugger. // For now, the default hasSuggestedItemOptions is false. hasSuggestedItemOptions = false; } _hasSuggestedItemOptions = hasSuggestedItemOptions || _data.DisplaySuggestionItem; // We prefer using the original snapshot, which should always be available from items provided by Roslyn's CompletionSource. // Only use data.Snapshot in the theoretically possible but rare case when all items we are handling are from some non-Roslyn CompletionSource. var snapshotForDocument = TryGetInitialTriggerLocation(_data, out var intialTriggerLocation) ? intialTriggerLocation.Snapshot : _data.Snapshot; _document = snapshotForDocument?.TextBuffer.AsTextContainer().GetOpenDocumentInCurrentContext(); if (_document != null) { _completionService = _document.GetLanguageService <CompletionService>(); _completionRules = _completionService?.GetRules(CompletionOptions.From(_document.Project)) ?? CompletionRules.Default; // Let us make the completion Helper used for non-Roslyn items case-sensitive. // We can change this if get requests from partner teams. _completionHelper = CompletionHelper.GetHelper(_document); _filterMethod = _completionService == null ? ((itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text)) : ((itemsWithPatternMatches, text) => _completionService.FilterItems(_document, itemsWithPatternMatches, text)); // Nothing to highlight if user hasn't typed anything yet. _highlightMatchingPortions = _filterText.Length > 0 && globalOptions.GetOption(CompletionViewOptions.HighlightMatchingPortionsOfCompletionListItems, _document.Project.Language); _showCompletionItemFilters = globalOptions.GetOption(CompletionViewOptions.ShowCompletionItemFilters, _document.Project.Language); } else { _completionService = null; _completionRules = CompletionRules.Default; // Let us make the completion Helper used for non-Roslyn items case-sensitive. // We can change this if get requests from partner teams. _completionHelper = new CompletionHelper(isCaseSensitive: true); _filterMethod = (itemsWithPatternMatches, text) => CompletionService.FilterItems(_completionHelper, itemsWithPatternMatches, text); _highlightMatchingPortions = false; _showCompletionItemFilters = true; } }
internal override async Task <CompletionDescription> GetDescriptionWorkerAsync( Document document, CompletionItem item, CompletionOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken) { var position = SymbolCompletionItem.GetContextPosition(item); // What EditorBrowsable settings were we previously passed in (if it mattered)? if (item.Properties.TryGetValue(HideAdvancedMembers, out var hideAdvancedMembersString) && bool.TryParse(hideAdvancedMembersString, out var hideAdvancedMembers)) { options = options with { HideAdvancedMembers = hideAdvancedMembers }; } var(token, semanticModel, symbols) = await GetSymbolsAsync(document, position, options, cancellationToken).ConfigureAwait(false); if (symbols.Length == 0) { return(CompletionDescription.Empty); } Contract.ThrowIfNull(semanticModel); var name = SymbolCompletionItem.GetSymbolName(item); var kind = SymbolCompletionItem.GetKind(item); var bestSymbols = symbols.WhereAsArray(s => s.Kind == kind && s.Name == name); return(await SymbolCompletionItem.GetDescriptionAsync(item, bestSymbols, document, semanticModel, displayOptions, cancellationToken).ConfigureAwait(false)); }
public async Task GettingCompletionListShoudNotRunSourceGenerator(bool forkBeforeFreeze) { var sourceMarkup = @" using System; namespace N { public class C1 { $$ } }"; MarkupTestFile.GetPosition(sourceMarkup.NormalizeLineEndings(), out var source, out int?position); var generatorRanCount = 0; var generator = new CallbackGenerator(onInit: _ => { }, onExecute: _ => Interlocked.Increment(ref generatorRanCount)); using var workspace = WorkspaceTestUtilities.CreateWorkspaceWithPartialSemantics(); var analyzerReference = new TestGeneratorReference(generator); var project = SolutionUtilities.AddEmptyProject(workspace.CurrentSolution) .AddAnalyzerReference(analyzerReference) .AddDocument("Document1.cs", sourceMarkup, filePath: "Document1.cs").Project; Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); var document = workspace.CurrentSolution.Projects.Single().Documents.Single(); var compeltionService = document.GetLanguageService <CompletionService>(); Assert.Equal(0, generatorRanCount); if (forkBeforeFreeze) { // Forking before freezing means we'll have to do extra work to produce the final compilation, // but we should still not be running generators. document = document.WithText(SourceText.From(sourceMarkup.Replace("C1", "C2"))); } // We want to make sure import completion providers are also participating. var options = CompletionOptions.From(document.Project.Solution.Options, document.Project.Language); var newOptions = options with { ShowItemsFromUnimportedNamespaces = true }; var(completionList, _) = await compeltionService.GetCompletionsInternalAsync(document, position.Value, options : newOptions); // We expect completion to run on frozen partial semantic, which won't run source generator. Assert.Equal(0, generatorRanCount); var expectedItem = forkBeforeFreeze ? "C2" : "C1"; Assert.True(completionList.Items.Select(item => item.DisplayText).Contains(expectedItem)); } }
public override InitializeResult OnInitialize(InitializeParams parameters) { this.RemoteConsole.NoLogsMessageNotification = NoLogsMessageNotification; var rootDirectory = new DirectoryInfo(parameters.rootPath); string workspaceName = rootDirectory.Name + "#" + parameters.processId; // Initialize the workspace typeCobolWorkspace = new Workspace(rootDirectory.FullName, workspaceName, _MessagesActionsQueue, Logger); //Propagate LSR testing options. if (LsrSourceTesting) { typeCobolWorkspace.IsLsrSourceTesting = LsrSourceTesting; } if (LsrScannerTesting) { typeCobolWorkspace.IsLsrScannerTesting = LsrScannerTesting; } if (LsrPreprocessTesting) { typeCobolWorkspace.IsLsrPreprocessinTesting = LsrPreprocessTesting; } if (LsrParserTesting) { typeCobolWorkspace.IsLsrParserTesting = LsrParserTesting; } if (LsrSemanticTesting) { typeCobolWorkspace.IsLsrSemanticTesting = LsrSemanticTesting; } typeCobolWorkspace.UseAntlrProgramParsing = UseAntlrProgramParsing; typeCobolWorkspace.TimerDisabledOption = TimerDisabledOption; typeCobolWorkspace.LoadingIssueEvent += LoadingIssueDetected; typeCobolWorkspace.ExceptionTriggered += ExceptionTriggered; typeCobolWorkspace.WarningTrigger += WarningTrigger; // Return language server capabilities var initializeResult = base.OnInitialize(parameters); initializeResult.capabilities.textDocumentSync = TextDocumentSyncKind.Incremental; initializeResult.capabilities.hoverProvider = true; CompletionOptions completionOptions = new CompletionOptions(); completionOptions.resolveProvider = false; completionOptions.triggerCharacters = new string[] { "::" }; initializeResult.capabilities.completionProvider = completionOptions; SignatureHelpOptions sigHelpOptions = new SignatureHelpOptions { triggerCharacters = new string[0] }; initializeResult.capabilities.signatureHelpProvider = sigHelpOptions; return(initializeResult); }
public void SimpleTest(string expected) { var model = new CompletionOptions { ResolveProvider = false, }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <CompletionOptions>(expected); deresult.Should().BeEquivalentTo(model); }
public override CompletionInfo GetCompletionItems(int position, CompletionOptions options, CancellationToken cancellationToken) { var result = _service.GetCompletionItems(position - _offset, options, cancellationToken); if (_offset > 0) { return(new CompletionInfo(result.Items, result.EditStart + _offset, result.EditLength)); } else { return(result); } }
public void SimpleTest(string expected) { var model = new CompletionOptions() { ResolveProvider = false, }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = JsonConvert.DeserializeObject <CompletionOptions>(expected); deresult.ShouldBeEquivalentTo(model); }
public static CompletionOptions GetOptions(this ICompletionSession session, IServiceProvider serviceProvider) { var pyService = serviceProvider.GetPythonToolsService(); var options = new CompletionOptions { ConvertTabsToSpaces = session.TextView.Options.IsConvertTabsToSpacesEnabled(), IndentSize = session.TextView.Options.GetIndentSize(), TabSize = session.TextView.Options.GetTabSize(), IntersectMembers = pyService.AdvancedOptions.IntersectMembers, HideAdvancedMembers = pyService.LangPrefs.HideAdvancedMembers, FilterCompletions = pyService.AdvancedOptions.FilterCompletions, }; return(options); }
public override CompletionInfo GetCompletionItems(int position, CompletionOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { if (this.TryGetBoundCode(cancellationToken, true, out var code) && code.HasSemantics) { // have try-catch to keep editor from crashing from parser bugs try { return(new KustoCompleter(code, options ?? CompletionOptions.Default, cancellationToken) .GetCompletionItems(position)); } catch (Exception) { } } return(CompletionInfo.Empty); }
/// <summary> /// Initializes a new instance with the specified properties. /// </summary> /// <param name="moniker">The unique, non-localized identifier for the /// completion set.</param> /// <param name="displayName">The localized name of the completion set. /// </param> /// <param name="applicableTo">The tracking span to which the /// completions apply.</param> /// <param name="completions">The list of completions.</param> /// <param name="options">The options to use for filtering and /// selecting items.</param> /// <param name="comparer">The comparer to use to order the provided /// completions.</param> /// <param name="matchInsertionText">If true, matches user input against /// the insertion text; otherwise, uses the display text.</param> public FuzzyCompletionSet( string moniker, string displayName, ITrackingSpan applicableTo, IEnumerable <DynamicallyVisibleCompletion> completions, CompletionOptions options, IComparer <Completion> comparer, bool matchInsertionText = false ) : base(moniker, displayName, applicableTo, null, null) { _matchInsertionText = matchInsertionText; _completions = new BulkObservableCollection <Completion>(); _completions.AddRange(completions .Where(c => c != null && !string.IsNullOrWhiteSpace(c.DisplayText)) .OrderBy(c => c, comparer) ); _comparer = new FuzzyStringMatcher(FuzzyMatchMode.Default); _shouldFilter = options.FilterCompletions; _shouldHideAdvanced = options.HideAdvancedMembers && !_completions.All(IsAdvanced); if (!_completions.Any()) { _completions = null; } if (_completions != null && _shouldFilter | _shouldHideAdvanced) { _filteredCompletions = new FilteredObservableCollection <Completion>(_completions); foreach (var c in _completions.Cast <DynamicallyVisibleCompletion>()) { c.Visible = !_shouldHideAdvanced || !IsAdvanced(c); } _filteredCompletions.Filter(IsVisible); } CommitByDefault = DefaultCommitByDefault; }
private async Task CreateSpellCheckCodeIssueAsync( CodeFixContext context, SyntaxToken nameToken, bool isGeneric, CancellationToken cancellationToken) { var document = context.Document; var service = CompletionService.GetService(document); // Disable snippets and unimported types from ever appearing in the completion items. // - It's very unlikely the user would ever misspell a snippet, then use spell-checking to fix it, // then try to invoke the snippet. // - We believe spell-check should only compare what you have typed to what symbol would be offered here. var options = CompletionOptions.From(document.Project.Solution.Options, document.Project.Language) with { SnippetsBehavior = SnippetsRule.NeverInclude, ShowItemsFromUnimportedNamespaces = false, IsExpandedCompletion = false, TargetTypedCompletionFilter = false }; var(completionList, _) = await service.GetCompletionsInternalAsync( document, nameToken.SpanStart, options, cancellationToken : cancellationToken).ConfigureAwait(false); if (completionList == null) { return; } var nameText = nameToken.ValueText; var similarityChecker = WordSimilarityChecker.Allocate(nameText, substringsAreSimilar: true); try { await CheckItemsAsync( context, nameToken, isGeneric, completionList, similarityChecker).ConfigureAwait(false); } finally { similarityChecker.Free(); } }
public async Task <(ImmutableArray <ImmutableArray <CompletionItem> >, bool)> GetAllTopLevelTypesAsync( Project currentProject, SyntaxContext syntaxContext, bool forceCacheCreation, CompletionOptions options, CancellationToken cancellationToken) { var(getCacheResults, isPartialResult) = await GetCacheEntriesAsync(currentProject, forceCacheCreation, cancellationToken).ConfigureAwait(false); var currentCompilation = await currentProject.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); return(getCacheResults.SelectAsArray(GetItemsFromCacheResult), isPartialResult); ImmutableArray <CompletionItem> GetItemsFromCacheResult(TypeImportCompletionCacheEntry cacheEntry) => cacheEntry.GetItemsForContext( currentCompilation, Language, GenericTypeSuffix, syntaxContext.IsAttributeNameContext, IsCaseSensitive, options.HideAdvancedMembers); }
public override bool IsInsertionTrigger(SourceText text, int insertedCharacterPosition, CompletionOptions options) => CompletionUtilities.IsTriggerAfterSpaceOrStartOfWordCharacter(text, insertedCharacterPosition, options);
/// <param name="kind">The type of template tag we are processing</param> /// <param name="templateText">The text of the template tag which we are offering a completion in</param> /// <param name="templateStart">The offset in the buffer where the template starts</param> /// <param name="triggerPoint">The point in the buffer where the completion was triggered</param> internal CompletionSet GetCompletionSet(CompletionOptions options, VsProjectAnalyzer analyzer, TemplateTokenKind kind, string templateText, int templateStart, SnapshotPoint triggerPoint, out ITrackingSpan applicableSpan) { int position = triggerPoint.Position - templateStart; IEnumerable <CompletionInfo> tags; IDjangoCompletionContext context; applicableSpan = GetWordSpan(templateText, templateStart, triggerPoint); switch (kind) { case TemplateTokenKind.Block: var block = DjangoBlock.Parse(templateText); if (block != null) { if (position <= block.ParseInfo.Start + block.ParseInfo.Command.Length) { // we are completing before the command // TODO: Return a new set of tags? Do nothing? Do this based upon ctrl-space? tags = FilterBlocks(CompletionInfo.ToCompletionInfo(analyzer.GetTags(), StandardGlyphGroup.GlyphKeyword), triggerPoint); } else { // we are in the arguments, let the block handle the completions context = new ProjectBlockCompletionContext(analyzer, _buffer); tags = block.GetCompletions(context, position); } } else { // no tag entered yet, provide the known list of tags. tags = FilterBlocks(CompletionInfo.ToCompletionInfo(analyzer.GetTags(), StandardGlyphGroup.GlyphKeyword), triggerPoint); } break; case TemplateTokenKind.Variable: var variable = DjangoVariable.Parse(templateText); context = new ProjectBlockCompletionContext(analyzer, _buffer); if (variable != null) { tags = variable.GetCompletions(context, position); } else { // show variable names tags = CompletionInfo.ToCompletionInfo(context.Variables, StandardGlyphGroup.GlyphGroupVariable); } break; default: throw new InvalidOperationException(); } var completions = tags .OrderBy(tag => tag.DisplayText, StringComparer.OrdinalIgnoreCase) .Select(tag => new DynamicallyVisibleCompletion( tag.DisplayText, tag.InsertionText, StripDocumentation(tag.Documentation), _glyphService.GetGlyph(tag.Glyph, StandardGlyphItem.GlyphItemPublic), "tag")); return(new FuzzyCompletionSet( "PythonDjangoTags", Resources.DjangoTagsCompletionSetDisplayName, applicableSpan, completions, options, CompletionComparer.UnderscoresLast)); }
public override bool IsInsertionTrigger(SourceText text, int characterPosition, CompletionOptions options) => text[characterPosition] is ('<' or '"') ||
public override bool IsInsertionTrigger(SourceText text, int characterPosition, CompletionOptions options) => CompletionUtilities.IsTriggerCharacter(text, characterPosition, options);
internal override CompletionRules GetRules(CompletionOptions options) => CompletionRules.Default;
public override CompletionInfo GetCompletionItems(int position, CompletionOptions options, CancellationToken cancellationToken) { return(CompletionInfo.Empty); }
private protected override Task VerifyWorkerAsync( string code, int position, string expectedItemOrNull, string expectedDescriptionOrNull, SourceCodeKind sourceCodeKind, bool usePreviousCharAsTrigger, bool checkForAbsence, int?glyph, int?matchPriority, bool?hasSuggestionItem, string displayTextSuffix, string displayTextPrefix, string inlineDescription, bool?isComplexTextEdit, List <CompletionFilter> matchingFilters, CompletionItemFlags?flags = null, CompletionOptions options = null, bool skipSpeculation = false) { return(base.VerifyWorkerAsync(code, position, expectedItemOrNull, expectedDescriptionOrNull, SourceCodeKind.Regular, usePreviousCharAsTrigger, checkForAbsence, glyph, matchPriority, hasSuggestionItem, displayTextSuffix, displayTextPrefix, inlineDescription, isComplexTextEdit, matchingFilters, flags, options)); }
public sealed override bool IsInsertionTrigger(SourceText text, int insertedCharacterPosition, CompletionOptions options) { // Should trigger in these cases ($$ is the cursor position) // [InternalsVisibleTo($$ -> user enters " // [InternalsVisibleTo("$$")] -> user enters any character var ch = text[insertedCharacterPosition]; if (ch == '\"') { return(true); } else { if (insertedCharacterPosition > 0) { ch = text[insertedCharacterPosition - 1]; if (ch == '\"') { return(ShouldTriggerAfterQuotes(text, insertedCharacterPosition)); } } } return(false); }
internal sealed override bool ShouldTriggerCompletion(HostLanguageServices languageServices, SourceText text, int caretPosition, CompletionTrigger trigger, CompletionOptions options) { foreach (var language in GetLanguageProviders(languageServices)) { var completionProvider = (language as IEmbeddedLanguageFeatures)?.CompletionProvider; if (completionProvider != null) { if (completionProvider.ShouldTriggerCompletion(text, caretPosition, trigger)) { return(true); } } } return(false); }
internal override Task <CompletionDescription?> GetDescriptionAsync(Document document, CompletionItem item, CompletionOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken) => GetLanguage(item).CompletionProvider.GetDescriptionAsync(document, item, cancellationToken);
public override bool IsInsertionTrigger(SourceText text, int insertedCharacterPosition, CompletionOptions options) { return(_provider.IsInsertionTrigger(text, insertedCharacterPosition)); }
internal sealed override bool ShouldTriggerCompletion(HostLanguageServices languageServices, SourceText text, int caretPosition, CompletionTrigger trigger, CompletionOptions options, OptionSet passThroughOptions) => ShouldTriggerCompletionImpl(text, caretPosition, trigger, options.TriggerOnTypingLetters);
protected override async Task <ImmutableArray <(ISymbol symbol, bool preselect)> > GetSymbolsAsync( CompletionContext?completionContext, CSharpSyntaxContext context, int position, CompletionOptions options, CancellationToken cancellationToken) { var result = await base.GetSymbolsAsync(completionContext, context, position, options, cancellationToken).ConfigureAwait(false); if (result.Any()) { var type = (ITypeSymbol)result.Single().symbol; var alias = await type.FindApplicableAliasAsync(position, context.SemanticModel, cancellationToken).ConfigureAwait(false); if (alias != null) { return(ImmutableArray.Create((alias, result.Single().preselect))); } } return(result); }
internal override Task <CompletionDescription> GetDescriptionWorkerAsync(Document document, CompletionItem item, CompletionOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken) => ImportCompletionItem.GetCompletionDescriptionAsync(document, item, displayOptions, cancellationToken);
public async Task <LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken) { var document = context.Document; Contract.ThrowIfNull(document); var completionService = document.Project.LanguageServices.GetRequiredService <CompletionService>(); var cacheEntry = GetCompletionListCacheEntry(completionItem); if (cacheEntry == null) { // Don't have a cache associated with this completion item, cannot resolve. context.TraceInformation("No cache entry found for the provided completion item at resolve time."); return(completionItem); } var list = cacheEntry.CompletionList; // Find the matching completion item in the completion list var selectedItem = list.Items.FirstOrDefault(cachedCompletionItem => MatchesLSPCompletionItem(completionItem, cachedCompletionItem)); if (selectedItem == null) { return(completionItem); } var options = CompletionOptions.From(document.Project); var displayOptions = SymbolDescriptionOptions.From(document.Project); var description = await completionService.GetDescriptionAsync(document, selectedItem, options, displayOptions, cancellationToken).ConfigureAwait(false) !; if (description != null) { var supportsVSExtensions = context.ClientCapabilities.HasVisualStudioLspCapability(); if (supportsVSExtensions) { var vsCompletionItem = (LSP.VSInternalCompletionItem)completionItem; vsCompletionItem.Description = new ClassifiedTextElement(description.TaggedParts .Select(tp => new ClassifiedTextRun(tp.Tag.ToClassificationTypeName(), tp.Text))); } else { var clientSupportsMarkdown = context.ClientCapabilities.TextDocument?.Completion?.CompletionItem?.DocumentationFormat.Contains(LSP.MarkupKind.Markdown) == true; completionItem.Documentation = ProtocolConversions.GetDocumentationMarkupContent(description.TaggedParts, document, clientSupportsMarkdown); } } // We compute the TextEdit resolves for complex text edits (e.g. override and partial // method completions) here. Lazily resolving TextEdits is technically a violation of // the LSP spec, but is currently supported by the VS client anyway. Once the VS client // adheres to the spec, this logic will need to change and VS will need to provide // official support for TextEdit resolution in some form. if (selectedItem.IsComplexTextEdit) { Contract.ThrowIfTrue(completionItem.InsertText != null); Contract.ThrowIfTrue(completionItem.TextEdit != null); var snippetsSupported = context.ClientCapabilities.TextDocument?.Completion?.CompletionItem?.SnippetSupport ?? false; completionItem.TextEdit = await GenerateTextEditAsync( document, completionService, selectedItem, snippetsSupported, cancellationToken).ConfigureAwait(false); } return(completionItem); }