public Model( DisconnectedBufferGraph disconnectedBufferGraph, TextSpan textSpan, ISignatureHelpProvider provider, IList<SignatureHelpItem> items, SignatureHelpItem selectedItem, int argumentIndex, int argumentCount, string argumentName, int? selectedParameter) { Contract.ThrowIfNull(selectedItem); Contract.ThrowIfFalse(items.Count != 0, "Must have at least one item."); Contract.ThrowIfFalse(items.Contains(selectedItem), "Selected item must be in list of items."); _disconnectedBufferGraph = disconnectedBufferGraph; this.TextSpan = textSpan; this.Items = items; this.Provider = provider; this.SelectedItem = selectedItem; this.ArgumentIndex = argumentIndex; this.ArgumentCount = argumentCount; this.ArgumentName = argumentName; this.SelectedParameter = selectedParameter; }
public SignatureHelpItem(SIGHLP.SignatureHelpItem signatureHelpItem) { if (signatureHelpItem == null) { throw new ArgumentNullException(nameof(signatureHelpItem)); } this.signatureHelpItem = signatureHelpItem; }
public Signature(ITrackingSpan applicableToSpan, SignatureHelpItem signatureHelpItem, int selectedParameterIndex) { if (selectedParameterIndex < -1 || selectedParameterIndex >= signatureHelpItem.Parameters.Length) { throw new ArgumentOutOfRangeException(nameof(selectedParameterIndex)); } this.ApplicableToSpan = applicableToSpan; _signatureHelpItem = signatureHelpItem; _parameterIndex = selectedParameterIndex; }
public static SignatureHelpSelection GetSelection( IList<SignatureHelpItem> items, SignatureHelpItem selectedItem, int argumentIndex, int argumentCount, string argumentName, bool isCaseSensitive) { var bestItem = GetBestItem(selectedItem, items, argumentIndex, argumentCount, argumentName, isCaseSensitive); var selectedParameter = GetSelectedParameter(bestItem, argumentIndex, argumentName, isCaseSensitive); return new SignatureHelpSelection(bestItem, selectedParameter); }
private static int GetSelectedParameter(SignatureHelpItem bestItem, int parameterIndex, string parameterName, bool isCaseSensitive) { if (parameterName != null) { var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; var index = bestItem.Parameters.IndexOf(p => comparer.Equals(p.Name, parameterName)); if (index >= 0) { return index; } } return parameterIndex; }
private SignatureHelpItem UpdateItem(SignatureHelpItem item, SupportedPlatformData platformData, ISymbol symbol) { var platformParts = platformData.ToDisplayParts().ToTaggedText(); if (platformParts.Length == 0) { return(item); } var startingNewLine = new List <TaggedText>(); startingNewLine.AddLineBreak(); var concatted = startingNewLine.Concat(platformParts); var updatedDescription = item.DescriptionParts.IsDefault ? concatted : item.DescriptionParts.Concat(concatted); item.DescriptionParts = updatedDescription.ToImmutableArrayOrEmpty(); return(item); }
private static SignatureHelpItem GetBestItem( SignatureHelpItem currentItem, IList<SignatureHelpItem> filteredItems, int selectedParameter, int argumentCount, string name, bool isCaseSensitive) { // If the current item is still applicable, then just keep it. if (filteredItems.Contains(currentItem) && IsApplicable(currentItem, argumentCount, name, isCaseSensitive)) { return currentItem; } // Try to find the first applicable item. If there is none, then that means the // selected parameter was outside the bounds of all methods. i.e. all methods only // went up to 3 parameters, and selected parameter is 3 or higher. In that case, // just pick the very last item as it is closest in parameter count. var result = filteredItems.FirstOrDefault(i => IsApplicable(i, argumentCount, name, isCaseSensitive)); if (result != null) { return result; } // if we couldn't find a best item, and they provided a name, then try again without // a name. if (name != null) { return GetBestItem(currentItem, filteredItems, selectedParameter, argumentCount, null, isCaseSensitive); } // If we don't have an item that can take that number of parameters, then just pick // the last item. Or stick with the current item if the last item isn't any better. var lastItem = filteredItems.Last(); if (currentItem.IsVariadic || currentItem.Parameters.Length == lastItem.Parameters.Length) { return currentItem; } return lastItem; }
private static bool Include(SignatureHelpItem item, IEnumerable<string> parameterNames) { var itemParameterNames = item.Parameters.Select(p => p.Name).ToSet(); return parameterNames.All(itemParameterNames.Contains); }
private SignatureHelpItem UpdateItem(SignatureHelpItem item, SupportedPlatformData platformData, ISymbol symbol) { var platformParts = platformData.ToDisplayParts(); if (platformParts.Count == 0) { return item; } var startingNewLine = new List<SymbolDisplayPart>(); startingNewLine.AddLineBreak(); var updatedDescription = item.DescriptionParts == null ? item.DescriptionParts.Concat(startingNewLine.Concat(platformParts)) : startingNewLine.Concat(platformParts); item.DescriptionParts = updatedDescription.ToImmutableArrayOrEmpty(); return item; }
private SignatureHelpItem UpdateItem(SignatureHelpItem item, SupportedPlatformData platformData, ISymbol symbol) { var platformParts = platformData.ToDisplayParts().ToTaggedText(); if (platformParts.Length == 0) { return item; } var startingNewLine = new List<TaggedText>(); startingNewLine.AddLineBreak(); var concatted = startingNewLine.Concat(platformParts); var updatedDescription = item.DescriptionParts.IsDefault ? concatted : item.DescriptionParts.Concat(concatted); item.DescriptionParts = updatedDescription.ToImmutableArrayOrEmpty(); return item; }
private static int GetParameterIndexForItem(SignatureHelpItem item, int? selectedParameter) { if (selectedParameter.HasValue) { if (selectedParameter.Value < item.Parameters.Length) { // If the selected parameter is within the range of parameters of this item then set // that as the current parameter. return selectedParameter.Value; } else if (item.IsVariadic) { // It wasn't in range, but the item takes an unlimited number of parameters. So // just set current parameter to the last parameter (the variadic one). return item.Parameters.Length - 1; } } // It was out of bounds, there is no current parameter now. return -1; }
public SignatureHelpSelection(SignatureHelpItem selectedItem, int? selectedParameter) : this() { _selectedItem = selectedItem; _selectedParameter = selectedParameter; }
public Model WithSelectedItem(SignatureHelpItem selectedItem) { return selectedItem == this.SelectedItem ? this : new Model(_disconnectedBufferGraph, TextSpan, Provider, Items, selectedItem, ArgumentIndex, ArgumentCount, ArgumentName, SelectedParameter); }
private SignatureHelpItem FixAnonymousTypeParts( ISymbol orderSymbol, SignatureHelpItem item, SemanticModel semanticModel, int position, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService) { var currentItem = new SymbolKeySignatureHelpItem( orderSymbol, item.IsVariadic, item.DocumentationFactory, anonymousTypeDisplayService.InlineDelegateAnonymousTypes(item.PrefixDisplayParts, semanticModel, position, symbolDisplayService), anonymousTypeDisplayService.InlineDelegateAnonymousTypes(item.SeparatorDisplayParts, semanticModel, position, symbolDisplayService), anonymousTypeDisplayService.InlineDelegateAnonymousTypes(item.SuffixDisplayParts, semanticModel, position, symbolDisplayService), item.Parameters.Select(p => InlineDelegateAnonymousTypes(p, semanticModel, position, symbolDisplayService, anonymousTypeDisplayService)), item.DescriptionParts); var directAnonymousTypeReferences = from part in currentItem.GetAllParts() where part.Symbol.IsNormalAnonymousType() select (INamedTypeSymbol)part.Symbol; var info = anonymousTypeDisplayService.GetNormalAnonymousTypeDisplayInfo( orderSymbol, directAnonymousTypeReferences, semanticModel, position, symbolDisplayService); if (info.AnonymousTypesParts.Count > 0) { var anonymousTypeParts = new List<SymbolDisplayPart> { new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, "\r\n\r\n") }; anonymousTypeParts.AddRange(info.AnonymousTypesParts); currentItem = new SymbolKeySignatureHelpItem( orderSymbol, currentItem.IsVariadic, currentItem.DocumentationFactory, info.ReplaceAnonymousTypes(currentItem.PrefixDisplayParts), info.ReplaceAnonymousTypes(currentItem.SeparatorDisplayParts), info.ReplaceAnonymousTypes(currentItem.SuffixDisplayParts), currentItem.Parameters.Select(p => ReplaceAnonymousTypes(p, info)), anonymousTypeParts); } return currentItem; }
private static bool IsApplicable(SignatureHelpItem item, int argumentCount, string name, bool isCaseSensitive) { // If they provided a name, then the item is only valid if it has a parameter that // matches that name. if (name != null) { var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; return item.Parameters.Any(p => comparer.Equals(p.Name, name)); } // An item is applicable if it has at least as many parameters as the selected // parameter index. i.e. if it has 2 parameters and we're at index 0 or 1 then it's // applicable. However, if it has 2 parameters and we're at index 2, then it's not // applicable. if (item.Parameters.Length >= argumentCount) { return true; } // However, if it is variadic then it is applicable as it can take any number of // items. if (item.IsVariadic) { return true; } // Also, we special case 0. that's because if the user has "Foo(" and foo takes no // arguments, then we'll see that it's arg count is 0. We still want to consider // any item applicable here though. return argumentCount == 0; }
private static bool Include(SignatureHelpItem item, IEnumerable <string> parameterNames) { var itemParameterNames = item.Parameters.Select(p => p.Name).ToSet(); return(parameterNames.All(itemParameterNames.Contains)); }
private static bool DisplayPartsMatch(SignatureHelpItem i1, SignatureHelpItem i2) { return i1.GetAllParts().SequenceEqual(i2.GetAllParts(), CompareParts); }
public void PresentItems( ITrackingSpan triggerSpan, IList<SignatureHelpItem> signatureHelpItems, SignatureHelpItem selectedItem, int? selectedParameter) { _signatureHelpItems = signatureHelpItems; _selectedItem = selectedItem; // Create all the editor signatures for the sig help items we have. this.CreateSignatures(triggerSpan, selectedParameter); // It's a new list of items. Either create the editor session if this is the // first time, or ask the editor session that we already have to recalculate. if (_editorSessionOpt == null) { // We're tracking the caret. Don't have the editor do it. _editorSessionOpt = _sigHelpBroker.CreateSignatureHelpSession( _textView, triggerSpan.GetStartTrackingPoint(PointTrackingMode.Negative), trackCaret: false); var debugTextView = _textView as IDebuggerTextView; if (debugTextView != null && !debugTextView.IsImmediateWindow) { debugTextView.HACK_StartCompletionSession(_editorSessionOpt); } _editorSessionOpt.Dismissed += (s, e) => OnEditorSessionDismissed(); _editorSessionOpt.SelectedSignatureChanged += OnSelectedSignatureChanged; } // So here's the deal. We cannot create the editor session and give it the right // signatures (even though we know what they are). Instead, the session with // call back into the ISignatureHelpSourceProvider (which is us) to get those // values. It will pass itself along with the calls back into // ISignatureHelpSourceProvider. So, in order to make that connection work, we // add properties to the session so that we can call back into ourselves, get // the signatures and add it to the session. if (!_editorSessionOpt.Properties.ContainsProperty(s_augmentSessionKey)) { _editorSessionOpt.Properties.AddProperty(s_augmentSessionKey, this); } try { // Don't want to get any callbacks while we do this. _ignoreSelectionStatusChangedEvent = true; _editorSessionOpt.Recalculate(); // Now let the editor know what the currently selected item is. Contract.Requires(_signatureMap.ContainsKey(selectedItem)); Contract.ThrowIfNull(_signatureMap); var defaultValue = _signatureMap.GetValueOrDefault(_selectedItem); if (_editorSessionOpt != null) { _editorSessionOpt.SelectedSignature = defaultValue; } } finally { _ignoreSelectionStatusChangedEvent = false; } }
public SignatureHelpResult(SignatureHelpItems items, SignatureHelpItem selectedItem, int? selectedParameter) { Items = items; SelectedItem = selectedItem; SelectedParameter = selectedParameter; }