public bool IsApplicable(CodeCompletionContext context)
{
if(!context.IsAvalilableAttributeValueCompletion)
return false;
return GetAppenderRef(context) != null;
}
public bool IsApplicable(CodeCompletionContext context)
{
if(context.IsAvalilableAttributeNameCompletion)
return false;
throw new System.NotImplementedException();
}
public PsiCodeCompletionContext(CodeCompletionContext context, TextLookupRanges completionRanges, PsiReparsedCompletionContext reparsedContext)
:
base(context)
{
ReparsedContext = reparsedContext;
Ranges = completionRanges;
}
public void InsertCompletionText(ICompletionWidget widget, CodeCompletionContext context)
{
// insert add/remove event handler code after +=/-=
editor.Replace (initialOffset, editor.Caret.Offset - initialOffset, this.DisplayText + ";");
// Search opening bracket of member
int pos = editor.Document.LocationToOffset (callingMember.BodyRegion.Start.Line - 1, callingMember.BodyRegion.Start.Column - 1);
while (pos < editor.Document.Length && editor.Document.GetCharAt (pos) != '{') {
pos++;
}
// Search closing bracket of member
pos = editor.Document.GetMatchingBracketOffset (pos) + 1;
pos = Math.Max (0, Math.Min (pos, editor.Document.Length - 1));
// Insert new event handler after closing bracket
string indent = editor.Document.GetLine (callingMember.Location.Line).GetIndentation (editor.Document);
StringBuilder sb = new StringBuilder ();
sb.AppendLine ();
sb.AppendLine ();
sb.Append (indent);
if (callingMember.IsStatic)
sb.Append ("static ");
sb.Append ("void ");sb.Append (this.DisplayText);sb.Append (' ');sb.Append (this.parameterList);sb.AppendLine ();
sb.Append (indent);sb.Append ("{");sb.AppendLine ();
sb.Append (indent);sb.Append (TextEditorProperties.IndentString);
int cursorPos = pos + sb.Length;
sb.AppendLine ();
sb.Append (indent);sb.Append ("}");
editor.Insert (pos, sb.ToString ());
editor.Caret.Offset = cursorPos;
}
public NTriplesCodeCompletionContext(
CodeCompletionContext context, TextLookupRanges completionRanges, NTriplesReparsedCompletionContext reparsedContext)
: base(context)
{
this.ReparsedContext = reparsedContext;
this.Ranges = completionRanges;
}
public override ISpecificCodeCompletionContext GetCompletionContext(CodeCompletionContext context)
{
var unterminatedContext = new NTriplesReparsedCompletionContext(context.File, context.SelectedTreeRange, "aaa");
unterminatedContext.Init();
IReference referenceToComplete = unterminatedContext.Reference;
ITreeNode elementToComplete = unterminatedContext.TreeNode;
if (elementToComplete == null)
{
return null;
}
TreeTextRange referenceRange = referenceToComplete != null
? referenceToComplete.GetTreeTextRange()
: GetElementRange(elementToComplete);
TextRange referenceDocumentRange = unterminatedContext.ToDocumentRange(referenceRange);
if (!referenceDocumentRange.IsValid)
{
return null;
}
if (!referenceDocumentRange.Contains(context.CaretDocumentRange.TextRange))
{
return null;
}
TextLookupRanges ranges = GetTextLookupRanges(context, referenceDocumentRange);
return new NTriplesCodeCompletionContext(context, ranges, unterminatedContext);
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
IParameterDescriptorProvider provider = GetParameterDescriptorProvider(context);
ICollection<IParameterDescriptor> descriptors = provider.GetParameterDescriptors();
// it's parameters conception hak, TODO fix conception
IXmlTag tag = context.GetAttributeTag();
Assert.CheckNotNull(tag);
foreach (IParameterDescriptor descriptor in descriptors)
{
if (!descriptor.IsAttribute)
continue;
// scipr declared attribjutes
// it's parameters conception hak, TODO fix conception
if(tag.GetAttribute(descriptor.Name) != null)
continue;
LookupItemBase item = CreateItem(descriptor, context);
item.InsertRange = new TextRange(0);
item.ReplaceRange = new TextRange(0, context.GetPrefix().Length);
result.Add(item);
}
}
public override ISpecificCodeCompletionContext GetCompletionContext(CodeCompletionContext context)
{
TreeOffset startOffset = context.SelectedTreeRange.StartOffset;
ITokenNode tokenNode = GetTokenNode(context);
if (tokenNode == null)
return null;
int offset = tokenNode.GetTreeStartOffset().Offset;
int start = startOffset.Offset - offset;
if (start <= 2)
return null;
string text = tokenNode.GetText();
if (start > text.Length)
return null;
string commentText = text.Substring(2, start - 2);
int emojiStart = commentText.LastIndexOf(':');
if (emojiStart < 0)
return null;
for (int index = emojiStart + 1; index < commentText.Length; ++index)
{
if ((index != emojiStart + 1 || !IsEmojiChar(commentText[index])) && (index <= emojiStart + 1 || !IsEmojiChar(commentText[index])))
return null;
}
DocumentRange documentRange = context.File.GetDocumentRange(new TreeTextRange(new TreeOffset(offset + emojiStart + 2), new TreeOffset(offset + start)));
if (!documentRange.IsValid())
return null;
return new ContextInDocComment(context, documentRange, new TextLookupRanges(documentRange.TextRange, documentRange.TextRange));
}
public bool IsApplicable(CodeCompletionContext context)
{
if(!context.IsAvalilableAttributeValueCompletion)
return false;
return true;
}
protected LookupItemBase CreateItem(IParameterDescriptor descriptor, CodeCompletionContext context)
{
if (descriptor.DecraedElement != null)
return new ParameterLookupItem(descriptor, new DeclaredElementLookupItemCreationContext(context.ProjectFile));
else
return new StaticParameterLookupItem(descriptor.Name);
}
public AbbreviatedTextLookupItem(string text, CodeCompletionContext context, IconId image)
: base(text, image, true)
{
this.context = context;
// When dealing with dynamic items providers, static items are simply merged into the list
// on each keystroke. If the dynamic item provider adds dynamic items, the merging happens
// like this:
// 1. Get a list of existing dynamic items
// 2. Remove any items that fail ILookupItem.Match
// 3. Retrieve the item's BaseDynamicRule.PrefixKey value. If it exists and is longer
// than the current prefix, remove it
// (I'm not sure on the reason for this, perhaps to handle deleting chars in the prefix?)
// 4. Loop over the new items
// a. If the item is ITextualLookupItem and has a BaseDynamicRule.PrefixKey value, look
// for the name in the (filtered) list of previous dynamic results. If it exists,
// don't add a new item
// b. Otherwise, add the item
//
// So, static items are always added and never removed. Dynamic items are only merged if
// they are ITextualLookupItem and have a BaseDynamicRule.PrefixKey value. Dynamic items
// are removed if they are ITextualLookupItem and their PrefixKey value is longer than
// the current prefix, presumably when the prefix has chars deleted
//
// Which means, to allow us to remove dynamic items on each keystroke, even when adding
// chars to the prefix, we need a dynamic item that implements ITextualLookupItem and
// that has a really long PrefixKey value. This is a hack.
PutData(BaseDynamicRule.PrefixKey, "really_long_string_that_shouldnt_match_so_that_the_item_is_removed");
}
public override ICompletionDataProvider HandleCodeCompletion (
CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength)
{
int pos = completionContext.TriggerOffset;
if (pos > 0 && Editor.GetCharAt (pos - 1) == completionChar) {
return HandleCodeCompletion ((CodeCompletionContext) completionContext, false, ref triggerWordLength);
}
return null;
}
private IParameterDescriptorProvider GetParameterDescriptorProvider(CodeCompletionContext context)
{
ITokenNode token = context.Token;
if (token.GetTokenType() == context.GetTokenTypes().SPACE &&
(token.GetPrevToken().GetTokenType() == context.GetTokenTypes().TAG_START
|| token.GetPrevToken().GetTokenType() == context.GetTokenTypes().IDENTIFIER))
return token.Parent as IParameterDescriptorProvider;
else
return token.Parent.Parent as IParameterDescriptorProvider;
}
public override bool IsApplicable(CodeCompletionContext context)
{
if (!context.IsAvalilableAttributeValueCompletion)
return false;
if (!IsAttributeOf<IDeclaredParameter>(L4NConstants.TYPE, context))
return false;
return true;
}
public override ICompletionDataProvider CodeCompletionCommand (CodeCompletionContext completionContext)
{
int pos = completionContext.TriggerOffset;
string txt = Editor.GetText (pos - 1, pos);
int triggerWordLength = 0;
ICompletionDataProvider cp = null;
if (txt.Length > 0)
cp = HandleCodeCompletion ((CodeCompletionContext) completionContext, true, ref triggerWordLength);
return cp;
}
public bool IsApplicable(CodeCompletionContext context)
{
if (!context.IsAvalilableAttributeNameCompletion)
return false;
IDeclaredParameter declaredParameter = GetDeclaredParameter(context);
if (declaredParameter == null)
return false;
return true;
}
///<summary>
///
/// Applies the rule
///
///</summary>
///
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
// do nothing
IUsingNamespaceDirective usingNamespaceDirective = context.Element.GetContainingElement<IUsingNamespaceDirective>(true);
if(context.Reference == null)
return;
ISymbolTable table = context.Reference.GetCompletionSymbolTable();
string[] names = table.Names("", true, delegate () { return false;});
}
public override bool IsApplicable(CodeCompletionContext context)
{
if(!context.IsAvalilableAttributeValueCompletion)
return false;
if(!IsAttributeOf<IAppender>(L4NConstants.TYPE, context))
return false;
// TODO introduce base class for <dynamic parameter>@type parameter@type and renderer@type
return true;
}
protected override ITypeElement GetBaseType(CodeCompletionContext context)
{
IDeclaredParameter declaredParameter = GetAttributeTag<IDeclaredParameter>(context);
Assert.CheckNotNull(declaredParameter);
IParameterDescriptor descriptor = declaredParameter.ParameterDescriptorProvider.GetParameterDescriptor(declaredParameter.Name);
if(descriptor.RequredType)
{
return ((IDeclaredType) descriptor.Type).GetTypeElement();
}
return null;
}
public bool IsApplicable(CodeCompletionContext context)
{
if(!context.IsAvalilableAttributeNameCompletion)
return false;
IParameterDescriptorProvider provider = GetParameterDescriptorProvider(context);
if(provider == null)
return false;
// if(!provider.IsAvailable)
// return false;
return true;
}
public bool IsApplicable(CodeCompletionContext context)
{
if (!context.IsAvalilableTagCompletion)
return false;
IParameterDescriptorProvider parameterDescriptorProvider = GetParameterDescriptorProvider(context);
if (parameterDescriptorProvider == null)
return false;
if (!parameterDescriptorProvider.IsAvailable)
return false;
return true;
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
IParameterDescriptorProvider parameterDescriptorProvider = GetParameterDescriptorProvider(context);
ICollection<IParameterDescriptor> descriptors = parameterDescriptorProvider.GetParameterDescriptors();
foreach (IParameterDescriptor descriptor in descriptors)
{
if (descriptor.IsAttribute)
continue;
LookupItemBase item = CreateItem(descriptor, context);
item.InsertRange = new TextRange(0);
item.ReplaceRange = new TextRange(0, context.GetPrefix().Length);
result.Add(item);
}
}
private ITokenNode GetTokenNode(CodeCompletionContext context)
{
if (!(context.File is ICSharpFile))
return null;
if (!context.SelectedTreeRange.IsValid() || context.SelectedTreeRange.Length > 0)
return null;
if (AutomaticCodeCompletionStrategyEx.MatchTokenType(null, context.File, context.TextControl,
token => token == CSharpTokenType.END_OF_LINE_COMMENT && token.IsComment))
{
var tokenNode = context.File.FindTokenAt(context.Document, context.TextControl.Caret.Offset() - 1) as ITokenNode;
if (tokenNode is IDocCommentNode) return null;
return tokenNode;
}
return null;
}
public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char completionChar)
{
CompletionDataList cdl = new CompletionDataList();
switch(completionChar)
{
case '.':
break;
case '>':
Console.WriteLine("c_char: {0}", completionChar);
Console.WriteLine("prev: {0}", Editor.GetCharAt(completionContext.TriggerOffset - 2));
break;
}
return cdl;
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
IAppenderRef appenderRef = GetAppenderRef(context);
Assert.CheckNotNull(appenderRef);
IL4NSection l4nSection = appenderRef.GetContainingElement<IL4NSection>(false);
Assert.CheckNotNull(l4nSection);
ICollection<IAppender> appenders = l4nSection.GetAppenders();
foreach (IAppender appender in appenders)
{
DeclaredElementLookupItem item =
new DeclaredElementLookupItem(new DeclaredElementInstance((IDeclaredElement)appender), new DeclaredElementLookupItemCreationContext(context.ProjectFile), L4NLanguageService.L4N);
item.InsertRange = new TextRange(0);
item.ReplaceRange = new TextRange(0, context.GetPrefix().Length);
result.Add(item);
}
}
public override ISpecificCodeCompletionContext GetCompletionContext(CodeCompletionContext context)
{
var solution = ReSharperSolution.XXLanguageXXSolution;
var nitraFile = solution.GetNitraFile(context.Document);
if (nitraFile == null)
return null;
var ast = nitraFile.Ast;
if (ast == null)
return null;
var pos = context.CaretTreeOffset.Offset;
var parseResult = ast.File.ParseResult;
NSpan replacementSpan;
var result = NitraUtils.CompleteWord(pos, parseResult, ast, out replacementSpan);
var textRange = new TextRange(replacementSpan.StartPos, replacementSpan.EndPos);
return new NitraCodeCompletionContext(context, result, GetTextLookupRanges(context, textRange));
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
List<ILookupItem> toRemove = new List<ILookupItem>();
foreach (ILookupItem item in result)
{
DeclaredElementLookupItem declaredElementLookupItem = item as DeclaredElementLookupItem;
if(declaredElementLookupItem == null)
continue;
IDeclaredElement element = declaredElementLookupItem.PreferredDeclaredElement.Element;
if(!(element is IClass) &&!(element is INamespace))
toRemove.Add(declaredElementLookupItem);
}
foreach (ILookupItem item in toRemove)
{
result.Remove(item);
}
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
IDeclaredParameter declaredParameter = GetDeclaredParameter(context);
Assert.CheckNotNull(declaredParameter);
IParameterDescriptor descriptor =
declaredParameter.ParameterDescriptorProvider.GetParameterDescriptor(declaredParameter.Name);
LookupItemBase item = null;
if (!descriptor.RequredType)
item = new TextLookupItem("value");
else
item = new TextLookupItem("type");
item.InsertRange = new TextRange(0);
item.ReplaceRange = new TextRange(0, context.GetPrefix().Length);
result.Add(item);
}
public void Apply(CodeCompletionContext context, IList<ILookupItem> result)
{
IXmlTag tag = context.GetAttributeTag();
Assert.CheckNotNull(tag);
IXmlAttribute attribute = context.Token.GetContainingElement<IXmlAttribute>(false);
Assert.CheckNotNull(attribute);
IParameterDescriptor descriptor = null;
IDeclaredParameter declaredParameter = tag as IDeclaredParameter;
if (declaredParameter != null && attribute.AttributeName == L4NConstants.VALUE)
{
descriptor = declaredParameter.ParameterDescriptorProvider.GetParameterDescriptor(declaredParameter.Name);
}
else
{
IParameterDescriptorProvider parameterDescriptorProvider = tag as IParameterDescriptorProvider;
if (parameterDescriptorProvider == null)
return;
descriptor = parameterDescriptorProvider.GetParameterDescriptor(attribute.AttributeName);
}
if(descriptor == null)
return;
if(!descriptor.IsEnumerable)
return;
string[] values = descriptor.PossibleValues;
if(values == null)
return;
foreach (string v in values)
{
TextLookupItem item = new TextLookupItem(v);
item.InsertRange = new TextRange(0);
item.ReplaceRange = new TextRange(0, context.GetPrefix().Length);
result.Add(item);
}
}
protected virtual ICompletionDataList HandleCodeCompletion(
CodeCompletionContext completionContext, bool forced, ref int triggerWordLength)
{
IEditableTextBuffer buf = this.EditableBuffer;
// completionChar may be a space even if the current char isn't, when ctrl-space is fired t
TextLocation currentLocation = new TextLocation(completionContext.TriggerLine, completionContext.TriggerLineOffset);
char currentChar = completionContext.TriggerOffset < 1? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 1);
char previousChar = completionContext.TriggerOffset < 2? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 2);
LoggingService.LogDebug("Attempting completion for state '{0}'x{1}, previousChar='{2}',"
+ " currentChar='{3}', forced='{4}'", tracker.Engine.CurrentState,
tracker.Engine.CurrentStateLength, previousChar, currentChar, forced);
//closing tag completion
if (tracker.Engine.CurrentState is XmlFreeState && currentChar == '>')
{
return(ClosingTagCompletion(buf, currentLocation));
}
// Auto insert '>' when '/' is typed inside tag state (for quick tag closing)
//FIXME: avoid doing this when the next non-whitespace char is ">" or ignore the next ">" typed
if (XmlEditorOptions.AutoInsertFragments && tracker.Engine.CurrentState is XmlTagState && currentChar == '/')
{
buf.InsertText(buf.CursorPosition, ">");
return(null);
}
//entity completion
if (currentChar == '&' && (tracker.Engine.CurrentState is XmlFreeState ||
tracker.Engine.CurrentState is XmlAttributeValueState))
{
CompletionDataList list = new CompletionDataList();
//TODO: need to tweak semicolon insertion
list.Add("apos").Description = "'";
list.Add("quot").Description = "\"";
list.Add("lt").Description = "<";
list.Add("gt").Description = ">";
list.Add("amp").Description = "&";
//not sure about these "completions". they're more like
//shortcuts than completions but they're pretty useful
list.Add("'").CompletionText = "apos;";
list.Add("\"").CompletionText = "quot;";
list.Add("<").CompletionText = "lt;";
list.Add(">").CompletionText = "gt;";
list.Add("&").CompletionText = "amp;";
GetEntityCompletions(list);
return(list);
}
//doctype completion
if (tracker.Engine.CurrentState is XmlDocTypeState)
{
if (tracker.Engine.CurrentStateLength == 1)
{
CompletionDataList list = GetDocTypeCompletions();
if (list != null && list.Count > 0)
{
return(list);
}
}
return(null);
}
//attribute value completion
//determine whether to trigger completion within attribute values quotes
if ((Tracker.Engine.CurrentState is XmlAttributeValueState)
//trigger on the opening quote
&& ((Tracker.Engine.CurrentStateLength == 1 && (currentChar == '\'' || currentChar == '"'))
//or trigger on first letter of value, if unforced
|| (forced || Tracker.Engine.CurrentStateLength == 2)))
{
var att = (XAttribute)Tracker.Engine.Nodes.Peek();
if (att.IsNamed)
{
var attributedOb = Tracker.Engine.Nodes.Peek(1) as IAttributedXObject;
if (attributedOb == null)
{
return(null);
}
//if triggered by first letter of value or forced, grab those letters
triggerWordLength = Tracker.Engine.CurrentStateLength - 1;
return(GetAttributeValueCompletions(attributedOb, att));
}
}
//attribute name completion
if ((forced && Tracker.Engine.Nodes.Peek() is IAttributedXObject && !tracker.Engine.Nodes.Peek().IsEnded) ||
((Tracker.Engine.CurrentState is XmlNameState &&
Tracker.Engine.CurrentState.Parent is XmlAttributeState) ||
Tracker.Engine.CurrentState is XmlTagState) &&
(Tracker.Engine.CurrentStateLength == 1 || forced))
{
IAttributedXObject attributedOb = (Tracker.Engine.Nodes.Peek() as IAttributedXObject) ??
Tracker.Engine.Nodes.Peek(1) as IAttributedXObject;
if (attributedOb == null)
{
return(null);
}
//attributes
if (attributedOb.Name.IsValid && (forced ||
(char.IsWhiteSpace(previousChar) && char.IsLetter(currentChar))))
{
if (!forced)
{
triggerWordLength = 1;
}
var existingAtts = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase);
foreach (XAttribute att in attributedOb.Attributes)
{
existingAtts [att.Name.FullName] = att.Value ?? string.Empty;
}
return(GetAttributeCompletions(attributedOb, existingAtts));
}
}
// if (Tracker.Engine.CurrentState is XmlFreeState) {
// if (line < 3) {
// cp.Add ("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
// }
//element completion
if (currentChar == '<' && tracker.Engine.CurrentState is XmlFreeState ||
(tracker.Engine.CurrentState is XmlNameState && forced))
{
CompletionDataList list = new CompletionDataList();
GetElementCompletions(list);
AddCloseTag(list, Tracker.Engine.Nodes);
return(list.Count > 0? list : null);
}
if (forced && Tracker.Engine.CurrentState is XmlFreeState)
{
CompletionDataList list = new CompletionDataList();
MonoDevelop.Ide.CodeTemplates.CodeTemplateService.AddCompletionDataForFileName(Document.Name, list);
return(list.Count > 0? list : null);
}
return(null);
}
public Task <ParameterHintingResult> HandleParameterCompletion(MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context, CodeCompletionContext completionContext,
UnderlyingDocumentInfo docInfo, char completionChar)
{
CodeCompletionContext ccc;
var completion = CreateCompletionAndUpdate(editor, context, docInfo, out ccc);
return(completion.HandleParameterCompletionAsync(completionContext, completionChar));
}
public ParameterDataProvider HandleParameterCompletion(MonoDevelop.Ide.Gui.Document realDocument, CodeCompletionContext completionContext, DocumentInfo info, LocalDocumentInfo localInfo, char completionChar)
{
CodeCompletionContext ccc;
using (var completion = CreateCompletion(realDocument, info, localInfo, out ccc)) {
return(completion.HandleParameterCompletion(completionContext, completionChar));
}
}
public override async System.Threading.Tasks.Task <ICompletionDataList> HandleCodeCompletionAsync(CodeCompletionContext completionContext, char completionChar, System.Threading.CancellationToken token)
{
char previousChar = defaultEditor.CaretOffset > 1 ? defaultEditor.GetCharAt(
defaultEditor.CaretOffset - 2) : ' ';
// Don't show completion window when directive's name is being typed
var directive = Tracker.Engine.Nodes.Peek() as RazorDirective;
if (directive != null && !directive.FirstBracket.HasValue)
{
return(null);
}
if (hiddenInfo != null && isInCSharpContext)
{
var list = (CompletionDataList)await completionBuilder.HandleCompletion(defaultEditor, defaultDocumentContext, completionContext,
hiddenInfo, completionChar, token);
if (list != null)
{
//filter out the C# templates, many of them are not valid
int oldCount = list.Count;
list = FilterCSharpTemplates(list);
int templates = list.Count - oldCount;
if (previousChar == '@')
{
RazorCompletion.AddAllRazorSymbols(list, razorDocument.PageInfo.HostKind);
}
if (templates > 0)
{
AddFilteredRazorTemplates(list, previousChar == '@', true);
}
}
return(list);
}
return(await base.HandleCodeCompletionAsync(completionContext, completionChar, token));
}
string ICompletionWidget.GetCompletionText(CodeCompletionContext ctx)
{
return(TokenText.Substring(ctx.TriggerOffset, ctx.TriggerWordLength));
}
public override Task <ParameterHintingResult> ParameterCompletionCommand(CodeCompletionContext completionContext)
{
return(HandleParameterCompletionAsync(completionContext, '('));
}
/// <summary>
/// Handles the parameter completion async. Invoked automatically on every keypress.
/// Contains scenarios for veeery perverted codes like: classInstancePointer ->
/// classmethod ( ( new tempClass<int>{ 1 , 2 , 3 } ) , (new int[1]{})) , but might be not ready for everything.
/// </summary>
/// <returns>The parameter completion async.</returns>
/// <param name="completionContext">Completion context.</param>
/// <param name="completionChar">Completion char.</param>
/// <param name="token">Token.</param>s
public override Task <ParameterHintingResult> HandleParameterCompletionAsync(
CodeCompletionContext completionContext,
char completionChar,
CancellationToken token = default(CancellationToken))
{
if (completionChar != '(' && completionChar != ',')
{
return(Task.FromResult((ParameterHintingResult)null));
}
var project = (CProject)DocumentContext.Project;
if (project == null || !project.HasLibClang)
{
return(Task.FromResult((ParameterHintingResult)null));
}
return(Task.Run(() => {
#region NEEDED_FOR_STARTOFFSET_:(
int inParenthesis = 0;
int nameEnd = completionContext.TriggerOffset - 1;
char endChar = Editor.GetCharAt(nameEnd);
char prevChar = Editor.GetCharAt(nameEnd - 1);
while (!(prevChar != '(' && endChar == '(' && inParenthesis <= 0) && //multiple '('
nameEnd > 1)
{
switch (endChar)
{
case ')':
inParenthesis++;
break;
case '(':
inParenthesis--;
break;
}
endChar = Editor.GetCharAt(--nameEnd);
prevChar = Editor.GetCharAt(nameEnd - 1);
}
WorkaroundWhitespaces(ref prevChar, ref nameEnd);
WorkaroundTemplateSpecifier(ref prevChar, ref nameEnd);
WorkaroundWhitespaces(ref prevChar, ref nameEnd);
int nameStart = nameEnd - 1;
//the actual name getting, march backwards while not a ., ->, space etc.
while (!allowedChars.Contains(prevChar) && nameStart > 1)
{
nameStart--;
prevChar = Editor.GetCharAt(nameStart - 1);
}
string functionName = Editor.Text.Substring(nameStart, nameEnd - nameStart);
#endregion
if (string.IsNullOrEmpty(functionName))
{
return (ParameterHintingResult)null;
}
unsavedFiles = project.UnsavedFiles.Get();
IntPtr pResults = project.ClangManager.CodeComplete(completionContext, unsavedFiles.ToArray(), DocumentContext.Name);
CXCodeCompleteResults results = Marshal.PtrToStructure <CXCodeCompleteResults> (pResults);
if (results.Results.ToInt64() != 0)
{
var parameterInformation = new List <OverloadCandidate> ();
for (int i = 0; i < results.NumResults; i++)
{
IntPtr iteratingPointer = results.Results + i * Marshal.SizeOf <CXCompletionResult> ();
CXCompletionResult resultItem = Marshal.PtrToStructure <CXCompletionResult> (iteratingPointer);
if (resultItem.CursorKind == CXCursorKind.@OverloadCandidate)
{
parameterInformation.Add(GetOverloadCandidate(resultItem));
}
}
clang.disposeCodeCompleteResults(pResults);
return (ParameterHintingResult) new ParameterDataProvider(nameStart, parameterInformation);
}
return (ParameterHintingResult)null;
}, token));
}
protected virtual async Task <ICompletionDataList> HandleCodeCompletion(
CodeCompletionContext completionContext, bool forced, CancellationToken token)
{
var buf = this.Editor;
// completionChar may be a space even if the current char isn't, when ctrl-space is fired t
var currentLocation = new DocumentLocation(completionContext.TriggerLine, completionContext.TriggerLineOffset);
char currentChar = completionContext.TriggerOffset < 1? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 1);
char previousChar = completionContext.TriggerOffset < 2? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 2);
LoggingService.LogDebug("Attempting completion for state '{0}'x{1}, previousChar='{2}',"
+ " currentChar='{3}', forced='{4}'", tracker.Engine.CurrentState,
tracker.Engine.CurrentStateLength, previousChar, currentChar, forced);
//closing tag completion
if (tracker.Engine.CurrentState is XmlRootState && currentChar == '>')
{
return(ClosingTagCompletion(buf, currentLocation));
}
// Auto insert '>' when '/' is typed inside tag state (for quick tag closing)
//FIXME: avoid doing this when the next non-whitespace char is ">" or ignore the next ">" typed
if (XmlEditorOptions.AutoInsertFragments && tracker.Engine.CurrentState is XmlTagState && currentChar == '/')
{
buf.InsertAtCaret(">");
return(null);
}
//entity completion
if (currentChar == '&' && (tracker.Engine.CurrentState is XmlRootState ||
tracker.Engine.CurrentState is XmlAttributeValueState))
{
var list = new CompletionDataList();
//TODO: need to tweak semicolon insertion
list.Add(new BaseXmlCompletionData("apos", "'"));
list.Add(new BaseXmlCompletionData("quot", "\""));
list.Add(new BaseXmlCompletionData("lt", "<"));
list.Add(new BaseXmlCompletionData("gt", ">"));
list.Add(new BaseXmlCompletionData("amp", "&"));
//not sure about these "completions". they're more like
//shortcuts than completions but they're pretty useful
list.Add(new BaseXmlCompletionData("'")
{
CompletionText = "apos;"
});
list.Add(new BaseXmlCompletionData("\"")
{
CompletionText = "quot;"
});
list.Add(new BaseXmlCompletionData("<")
{
CompletionText = "lt;"
});
list.Add(new BaseXmlCompletionData(">")
{
CompletionText = "gt;"
});
list.Add(new BaseXmlCompletionData("&")
{
CompletionText = "amp;"
});
var ecList = await GetEntityCompletions(token);
list.AddRange(ecList);
return(list);
}
//doctype completion
if (tracker.Engine.CurrentState is XmlDocTypeState)
{
if (tracker.Engine.CurrentStateLength == 1)
{
CompletionDataList list = await GetDocTypeCompletions(token);
if (list != null && list.Count > 0)
{
return(list);
}
}
return(null);
}
//attribute value completion
//determine whether to trigger completion within attribute values quotes
if ((Tracker.Engine.CurrentState is XmlAttributeValueState)
//trigger on the opening quote
&& ((Tracker.Engine.CurrentStateLength == 1 && (currentChar == '\'' || currentChar == '"'))
//or trigger on first letter of value, if unforced
|| (forced || Tracker.Engine.CurrentStateLength == 2)))
{
var att = (XAttribute)Tracker.Engine.Nodes.Peek();
if (att.IsNamed)
{
var attributedOb = Tracker.Engine.Nodes.Peek(1) as IAttributedXObject;
if (attributedOb == null)
{
return(null);
}
//if triggered by first letter of value or forced, grab those letters
var result = await GetAttributeValueCompletions(attributedOb, att, token);
if (result != null)
{
result.TriggerWordLength = Tracker.Engine.CurrentStateLength - 1;
return(result);
}
return(null);
}
}
//attribute name completion
if ((forced && Tracker.Engine.Nodes.Peek() is IAttributedXObject && !tracker.Engine.Nodes.Peek().IsEnded) ||
((Tracker.Engine.CurrentState is XmlNameState &&
Tracker.Engine.CurrentState.Parent is XmlAttributeState) ||
Tracker.Engine.CurrentState is XmlTagState))
{
IAttributedXObject attributedOb = (Tracker.Engine.Nodes.Peek() as IAttributedXObject) ??
Tracker.Engine.Nodes.Peek(1) as IAttributedXObject;
if (attributedOb == null || !attributedOb.Name.IsValid)
{
return(null);
}
var currentIsNameStart = XmlNameState.IsValidNameStart(currentChar);
var currentIsWhiteSpace = char.IsWhiteSpace(currentChar);
var previousIsWhiteSpace = char.IsWhiteSpace(previousChar);
bool shouldTriggerAttributeCompletion = forced ||
(currentIsNameStart && previousIsWhiteSpace) ||
currentIsWhiteSpace;
if (!shouldTriggerAttributeCompletion)
{
return(null);
}
var existingAtts = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase);
foreach (XAttribute att in attributedOb.Attributes)
{
existingAtts [att.Name.FullName] = att.Value ?? string.Empty;
}
var result = await GetAttributeCompletions(attributedOb, existingAtts, token);
if (result != null)
{
if (!forced && currentIsNameStart)
{
result.TriggerWordLength = 1;
}
result.AutoSelect = !currentIsWhiteSpace;
result.AddKeyHandler(new AttributeKeyHandler());
return(result);
}
}
//element completion
if (currentChar == '<' && tracker.Engine.CurrentState is XmlRootState ||
(tracker.Engine.CurrentState is XmlNameState && forced))
{
var list = await GetElementCompletions(token);
if (completionContext.TriggerLine == 1 && completionContext.TriggerOffset == 1)
{
var encoding = Editor.Encoding.WebName;
list.Add(new BaseXmlCompletionData($"?xml version=\"1.0\" encoding=\"{encoding}\" ?>"));
}
AddCloseTag(list, Tracker.Engine.Nodes);
return(list.Count > 0 ? list : null);
}
if (forced && Tracker.Engine.CurrentState is XmlRootState)
{
var list = new CompletionDataList();
MonoDevelop.Ide.CodeTemplates.CodeTemplateService.AddCompletionDataForFileName(DocumentContext.Name, list);
return(list.Count > 0? list : null);
}
return(null);
}
public override Task <MonoDevelop.Ide.CodeCompletion.ParameterHintingResult> HandleParameterCompletionAsync(CodeCompletionContext completionContext, Ide.Editor.Extension.SignatureHelpTriggerInfo triggerInfo, CancellationToken token = default(CancellationToken))
{
return(InternalHandleParameterCompletionCommand(completionContext, triggerInfo, token));
}
async Task <ICompletionDataList> InternalHandleCodeCompletion(CodeCompletionContext completionContext, CompletionTriggerInfo triggerInfo, int triggerWordLength, CancellationToken token, bool forceSymbolCompletion = false)
{
var analysisDocument = DocumentContext.AnalysisDocument;
if (analysisDocument == null)
{
return(EmptyCompletionDataList);
}
var cs = DocumentContext.RoslynWorkspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService <CompletionService> ();
SourceText sourceText;
if (!analysisDocument.TryGetText(out sourceText))
{
return(EmptyCompletionDataList);
}
CompletionTriggerKind kind;
switch (triggerInfo.CompletionTriggerReason)
{
case CompletionTriggerReason.CharTyped:
kind = CompletionTriggerKind.Insertion;
if (triggerInfo.TriggerCharacter == '{')
{
return(EmptyCompletionDataList);
}
break;
case CompletionTriggerReason.CompletionCommand:
kind = CompletionTriggerKind.InvokeAndCommitIfUnique;
break;
case CompletionTriggerReason.BackspaceOrDeleteCommand:
kind = CompletionTriggerKind.Deletion;
break;
case CompletionTriggerReason.RetriggerCommand:
kind = CompletionTriggerKind.InvokeAndCommitIfUnique;
break;
default:
kind = CompletionTriggerKind.Insertion;
break;
}
var triggerSnapshot = Editor.GetPlatformTextBuffer().CurrentSnapshot;
var trigger = new CompletionTrigger(kind, triggerInfo.TriggerCharacter.HasValue ? triggerInfo.TriggerCharacter.Value : '\0');
if (triggerInfo.CompletionTriggerReason == CompletionTriggerReason.CharTyped)
{
if (!cs.ShouldTriggerCompletion(sourceText, completionContext.TriggerOffset, trigger, null))
{
return(EmptyCompletionDataList);
}
}
Counters.ProcessCodeCompletion.Trace("C#: Getting completions");
var customOptions = DocumentContext.RoslynWorkspace.Options
.WithChangedOption(CompletionOptions.TriggerOnDeletion, LanguageNames.CSharp, true)
.WithChangedOption(CompletionOptions.HideAdvancedMembers, LanguageNames.CSharp, IdeApp.Preferences.CompletionOptionsHideAdvancedMembers)
// Roslyn's implementation of this feature doesn't work correctly in old editor
.WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, false);
var completionList = await Task.Run(() => cs.GetCompletionsAsync(analysisDocument, Editor.CaretOffset, trigger, options: customOptions, cancellationToken: token)).ConfigureAwait(false);
Counters.ProcessCodeCompletion.Trace("C#: Got completions");
if (completionList == null)
{
return(EmptyCompletionDataList);
}
var result = new CompletionDataList();
result.TriggerWordLength = triggerWordLength;
CSharpCompletionData defaultCompletionData = null;
bool first = true, addProtocolCompletion = false;
foreach (var item in completionList.Items)
{
if (string.IsNullOrEmpty(item.DisplayText))
{
continue;
}
var data = new CSharpCompletionData(analysisDocument, triggerSnapshot, cs, item);
if (first)
{
first = false;
addProtocolCompletion = data.Provider is OverrideCompletionProvider;
}
result.Add(data);
if (item.Rules.MatchPriority > 0)
{
if (defaultCompletionData == null || defaultCompletionData.Rules.MatchPriority < item.Rules.MatchPriority)
{
defaultCompletionData = data;
}
}
}
result.AutoCompleteUniqueMatch = (triggerInfo.CompletionTriggerReason == CompletionTriggerReason.CompletionCommand);
var partialDoc = analysisDocument.WithFrozenPartialSemantics(token);
var semanticModel = await partialDoc.GetSemanticModelAsync(token).ConfigureAwait(false);
var syntaxContext = CSharpSyntaxContext.CreateContext(DocumentContext.RoslynWorkspace, semanticModel, completionContext.TriggerOffset, token);
if (forceSymbolCompletion || IdeApp.Preferences.AddImportedItemsToCompletionList)
{
Counters.ProcessCodeCompletion.Trace("C#: Adding import completion data");
AddImportCompletionData(syntaxContext, result, semanticModel, completionContext.TriggerOffset, token);
Counters.ProcessCodeCompletion.Trace("C#: Added import completion data");
}
if (defaultCompletionData != null)
{
result.DefaultCompletionString = defaultCompletionData.DisplayText;
}
if (completionList.SuggestionModeItem != null)
{
if (completionList.Items.Contains(completionList.SuggestionModeItem))
{
result.DefaultCompletionString = completionList.SuggestionModeItem.DisplayText;
}
// if a suggestion mode item is present autoselection is disabled
// for example in the lambda case the suggestion mode item is '<lambda expression>' which is not part of the completion item list but taggs the completion list as auto select == false.
result.AutoSelect = false;
}
if (triggerInfo.TriggerCharacter == '_' && triggerWordLength == 1)
{
result.AutoSelect = false;
}
if (triggerInfo.TriggerCharacter == ' ')
{
result.AutoCompleteEmptyMatch = true;
}
return(result);
}
void ICompletionWidget.SetCompletionText(CodeCompletionContext ctx, string partial_word, string complete_word, int completeWordOffset)
{
}
public override bool IsApplicable(CodeCompletionContext context) => context.File is IFSharpFile;
string ICompletionWidget.GetCompletionText(CodeCompletionContext ctx)
{
return(Buffer.GetText(Buffer.GetIterAtOffset(ctx.TriggerOffset), Buffer.GetIterAtMark(Buffer.InsertMark), false));
}
CSharpCompletionTextEditorExtension CreateCompletion(MonoDevelop.Ide.Gui.Document realDocument, DocumentInfo info, LocalDocumentInfo localInfo, out CodeCompletionContext codeCompletionContext)
{
var doc = new Mono.TextEditor.TextDocument()
{
Text = localInfo.LocalDocument,
};
var documentLocation = doc.OffsetToLocation(localInfo.CaretPosition);
codeCompletionContext = new CodeCompletionContext()
{
TriggerOffset = localInfo.CaretPosition,
TriggerLine = documentLocation.Line,
TriggerLineOffset = documentLocation.Column - 1
};
return(new CSharpCompletionTextEditorExtension(localInfo.HiddenDocument)
{
CompletionWidget = CreateCompletionWidget(realDocument, localInfo)
});
}
public string GetCompletionText(CodeCompletionContext ctx)
{
return(Text.Substring(ctx.TriggerOffset, ctx.TriggerWordLength));
}
public ICompletionDataList HandleCompletion(MonoDevelop.Ide.Gui.Document realDocument, CodeCompletionContext completionContext, DocumentInfo info, LocalDocumentInfo localInfo, char currentChar, ref int triggerWordLength)
{
CodeCompletionContext ccc;
using (var completion = CreateCompletion(realDocument, info, localInfo, out ccc)) {
return(completion.HandleCodeCompletion(completionContext, currentChar, ref triggerWordLength));
}
}
public void SetCompletionText(CodeCompletionContext ctx, string partial_word, string complete_word, int completeWordOffset)
{
Text = complete_word;
gtkEntry.Position = complete_word.Length;
}
protected override async Task <ICompletionDataList> HandleCodeCompletion(CodeCompletionContext completionContext, bool forced, CancellationToken token)
{
isParameterValueCompletion = false;
return(await base.HandleCodeCompletion(completionContext, forced, token));
}
public string GetCompletionText(CodeCompletionContext ctx)
{
return("");
}
public Task <ICompletionDataList> HandleCompletion(MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context, CodeCompletionContext completionContext,
UnderlyingDocumentInfo docInfo, char currentChar, CancellationToken token)
{
CodeCompletionContext ccc;
var completion = CreateCompletionAndUpdate(editor, context, docInfo, out ccc);
return(completion.HandleCodeCompletionAsync(completionContext, currentChar, token));
}
public void SetCompletionText(CodeCompletionContext ctx, string partial_word, string complete_word, int offset)
{
this.CompletedWord = complete_word;
}
ICompletionDataList InternalHandleCodeCompletion(CodeCompletionContext completionContext, char completionChar, bool ctrlSpace, ref int triggerWordLength)
{
var data = TextEditorData;
if (data.CurrentMode is TextLinkEditMode)
{
if (((TextLinkEditMode)data.CurrentMode).TextLinkMode == TextLinkMode.EditIdentifier)
{
return(null);
}
}
if (Unit == null || CSharpUnresolvedFile == null)
{
return(null);
}
if (typeSystemSegmentTree == null)
{
return(null);
}
var list = new CSharpCompletionDataList();
list.Resolver = CSharpUnresolvedFile != null?CSharpUnresolvedFile.GetResolver(UnresolvedFileCompilation, Document.Editor.Caret.Location) : new CSharpResolver(Compilation);
var ctx = CSharpUnresolvedFile.GetTypeResolveContext(UnresolvedFileCompilation, data.Caret.Location) as CSharpTypeResolveContext;
var engine = new CSharpCompletionEngine(
data.Document,
typeSystemSegmentTree,
new CompletionDataFactory(this, new CSharpResolver(ctx)),
Document.GetProjectContext(),
ctx
);
if (Document.HasProject)
{
var configuration = Document.Project.GetConfiguration(MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration;
var par = configuration != null ? configuration.CompilationParameters as CSharpCompilerParameters : null;
if (par != null)
{
engine.LanguageVersion = MonoDevelop.CSharp.Parser.TypeSystemParser.ConvertLanguageVersion(par.LangVersion);
}
}
engine.FormattingPolicy = FormattingPolicy.CreateOptions();
engine.EolMarker = data.EolMarker;
engine.IndentString = data.Options.IndentationString;
try {
foreach (var cd in engine.GetCompletionData(completionContext.TriggerOffset, ctrlSpace))
{
list.Add(cd);
if (cd is IListData)
{
((IListData)cd).List = list;
}
}
} catch (Exception e) {
LoggingService.LogError("Error while getting completion data.", e);
}
list.AutoCompleteEmptyMatch = engine.AutoCompleteEmptyMatch;
list.AutoCompleteEmptyMatchOnCurlyBrace = engine.AutoCompleteEmptyMatchOnCurlyBracket;
list.AutoSelect = engine.AutoSelect;
list.DefaultCompletionString = engine.DefaultCompletionString;
list.CloseOnSquareBrackets = engine.CloseOnSquareBrackets;
if (ctrlSpace)
{
list.AutoCompleteUniqueMatch = true;
}
return(list.Count > 0 ? list : null);
}
void OnCompletionWindowClosed()
{
currentCompletionContext = null;
}
public Task <MonoDevelop.Ide.CodeCompletion.ParameterHintingResult> InternalHandleParameterCompletionCommand(CodeCompletionContext completionContext, Ide.Editor.Extension.SignatureHelpTriggerInfo triggerInfo, CancellationToken token = default(CancellationToken))
{
var data = Editor;
bool force = triggerInfo.TriggerReason != Ide.Editor.Extension.SignatureHelpTriggerReason.InvokeSignatureHelpCommand;
ImmutableArray <ISignatureHelpProvider> providers;
if (!force)
{
if (triggerInfo.TriggerReason == Ide.Editor.Extension.SignatureHelpTriggerReason.TypeCharCommand)
{
providers = signatureProviders.Value.WhereAsArray(provider => provider.IsTriggerCharacter(triggerInfo.TriggerCharacter.Value));
}
else if (triggerInfo.TriggerReason == Ide.Editor.Extension.SignatureHelpTriggerReason.RetriggerCommand)
{
providers = signatureProviders.Value.WhereAsArray(provider => provider.IsRetriggerCharacter(triggerInfo.TriggerCharacter.Value));
}
else
{
providers = signatureProviders.Value;
}
if (providers.Length == 0)
{
return(emptyParameterHintingResultTask);
}
}
else
{
providers = signatureProviders.Value;
}
if (Editor.EditMode != EditMode.Edit)
{
return(emptyParameterHintingResultTask);
}
var offset = Editor.CaretOffset;
try {
var analysisDocument = DocumentContext.AnalysisDocument;
if (analysisDocument == null)
{
return(emptyParameterHintingResultTask);
}
var result = new RoslynParameterHintingEngine().GetParameterDataProviderAsync(
providers,
analysisDocument,
offset,
triggerInfo.ToRoslyn(),
token
);
return(result);
} catch (Exception e) {
LoggingService.LogError("Unexpected parameter completion exception." + Environment.NewLine +
"FileName: " + DocumentContext.Name + Environment.NewLine +
"Position: line=" + completionContext.TriggerLine + " col=" + completionContext.TriggerLineOffset + Environment.NewLine +
"Line text: " + Editor.GetLineText(completionContext.TriggerLine),
e);
return(emptyParameterHintingResultTask);
}
}
public virtual ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext,
char completionChar, ref int triggerWordLength)
{
return(HandleCodeCompletion(completionContext, completionChar));
}
// static bool ContainsPublicConstructors (ITypeDefinition t)
// {
// if (t.Methods.Count (m => m.IsConstructor) == 0)
// return true;
// return t.Methods.Any (m => m.IsConstructor && m.IsPublic);
// }
// CompletionDataList result = new ProjectDomCompletionDataList ();
// // "var o = new " needs special treatment.
// if (returnType == null && returnTypeUnresolved != null && returnTypeUnresolved.FullName == "var")
// returnType = returnTypeUnresolved = DomReturnType.Object;
//
// // ExpressionContext.TypeExpressionContext tce = context as ExpressionContext.TypeExpressionContext;
//
// CompletionDataCollector col = new CompletionDataCollector (this, dom, result, Document.CompilationUnit, callingType, location);
// IType type = null;
// if (returnType != null)
// type = dom.GetType (returnType);
// if (type == null)
// type = dom.SearchType (Document.CompilationUnit, callingType, location, returnTypeUnresolved);
//
// // special handling for nullable types: Bug 674516 - new completion for nullables should not include "Nullable"
// if (type is InstantiatedType && ((InstantiatedType)type).UninstantiatedType.FullName == "System.Nullable" && ((InstantiatedType)type).GenericParameters.Count == 1) {
// var genericParameter = ((InstantiatedType)type).GenericParameters [0];
// returnType = returnTypeUnresolved = Document.CompilationUnit.ShortenTypeName (genericParameter, location);
// type = dom.SearchType (Document.CompilationUnit, callingType, location, genericParameter);
// }
//
// if (type == null || !(type.IsAbstract || type.ClassType == ClassType.Interface)) {
// if (type == null || type.ConstructorCount == 0 || type.Methods.Any (c => c.IsConstructor && c.IsAccessibleFrom (dom, callingType, type, callingType != null && dom.GetInheritanceTree (callingType).Any (x => x.FullName == type.FullName)))) {
// if (returnTypeUnresolved != null) {
// col.FullyQualify = true;
// CompletionData unresovedCompletionData = col.Add (returnTypeUnresolved);
// col.FullyQualify = false;
// // don't set default completion string for arrays, since it interferes with:
// // string[] arr = new string[] vs new { "a"}
// if (returnTypeUnresolved.ArrayDimensions == 0)
// result.DefaultCompletionString = StripGenerics (unresovedCompletionData.CompletionText);
// } else {
// CompletionData unresovedCompletionData = col.Add (returnType);
// if (returnType.ArrayDimensions == 0)
// result.DefaultCompletionString = StripGenerics (unresovedCompletionData.CompletionText);
// }
// }
// }
//
// // if (tce != null && tce.Type != null) {
// // result.DefaultCompletionString = StripGenerics (col.AddCompletionData (result, tce.Type).CompletionString);
// // }
// // else {
// // }
// if (type == null)
// return result;
// HashSet<string > usedNamespaces = new HashSet<string> (GetUsedNamespaces ());
// if (type.FullName == DomReturnType.Object.FullName)
// AddPrimitiveTypes (col);
//
// foreach (IType curType in dom.GetSubclasses (type)) {
// if (context != null && context.FilterEntry (curType))
// continue;
// if ((curType.TypeModifier & TypeModifier.HasOnlyHiddenConstructors) == TypeModifier.HasOnlyHiddenConstructors)
// continue;
// if (usedNamespaces.Contains (curType.Namespace)) {
// if (curType.ConstructorCount > 0) {
// if (!(curType.Methods.Any (c => c.IsConstructor && c.IsAccessibleFrom (dom, curType, callingType, callingType != null && dom.GetInheritanceTree (callingType).Any (x => x.FullName == curType.FullName)))))
// continue;
// }
// col.Add (curType);
// } else {
// string nsName = curType.Namespace;
// int idx = nsName.IndexOf ('.');
// if (idx >= 0)
// nsName = nsName.Substring (0, idx);
// col.Add (new Namespace (nsName));
// }
// }
//
// // add aliases
// if (returnType != null) {
// foreach (IUsing u in Document.CompilationUnit.Usings) {
// foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) {
// if (alias.Value.ToInvariantString () == returnType.ToInvariantString ())
// result.Add (alias.Key, "md-class");
// }
// }
// }
//
// return result;
// }
// IEnumerable<ICompletionData> GetDefineCompletionData ()
// {
// if (Document.Project == null)
// yield break;
//
// var symbols = new Dictionary<string, string> ();
// var cp = new ProjectDomCompletionDataList ();
// foreach (DotNetProjectConfiguration conf in Document.Project.Configurations) {
// var cparams = conf.CompilationParameters as CSharpCompilerParameters;
// if (cparams != null) {
// string[] syms = cparams.DefineSymbols.Split (';');
// foreach (string s in syms) {
// string ss = s.Trim ();
// if (ss.Length > 0 && !symbols.ContainsKey (ss)) {
// symbols [ss] = ss;
// yield return factory.CreateLiteralCompletionData (ss);
// }
// }
// }
// }
// }
public override Task <Ide.CodeCompletion.ParameterHintingResult> ParameterCompletionCommand(CodeCompletionContext completionContext)
{
if (completionContext == null)
{
throw new ArgumentNullException(nameof(completionContext));
}
char ch = completionContext.TriggerOffset > 0 ? Editor.GetCharAt(completionContext.TriggerOffset - 1) : '\0';
var info = new Ide.Editor.Extension.SignatureHelpTriggerInfo(Ide.Editor.Extension.SignatureHelpTriggerReason.InvokeSignatureHelpCommand, ch);
return(InternalHandleParameterCompletionCommand(completionContext, info, default(CancellationToken)));
}
public virtual ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext,
char completionChar)
{
return(null);
}
public override bool IsApplicable(CodeCompletionContext context)
{
return context.File is ICSharpFile;
}
public void SetCompletionText(CodeCompletionContext ctx, string partial_word, string complete_word)
{
SetCompletionText(ctx, partial_word, complete_word, complete_word.Length);
}
string ICompletionWidget.GetCompletionText(CodeCompletionContext ctx)
{
return("");
}
public override bool IsApplicable(CodeCompletionContext context)
{
return(context.File is ICSharpFile);
}
