void AddClosingTagCompletion(XamlContext context, DefaultCompletionItemList list, XamlAstResolver resolver)
{
if (context.ParentElement != null && !context.InRoot)
{
ResolveResult rr = resolver.ResolveElement(context.ParentElement);
TypeResolveResult trr = rr as TypeResolveResult;
MemberResolveResult mrr = rr as MemberResolveResult;
if (trr != null)
{
if (trr.IsError)
{
return;
}
list.Items.Add(new XamlCompletionItem("/" + context.ParentElement.Name, trr.Type.GetDefinition()));
}
else if (mrr != null)
{
if (mrr.IsError)
{
return;
}
list.Items.Add(new XamlCompletionItem("/" + context.ParentElement.Name, mrr.Member));
}
}
}
public virtual ICompletionItemList GenerateCompletionList(ITextEditor editor, IProjectContent projectContent)
{
int caretLineNumber = editor.Caret.Line;
int caretColumn = editor.Caret.Column;
IDocumentLine caretLine = editor.Document.GetLine(caretLineNumber);
string lineText = caretLine.Text;
if (!lineText.Trim().StartsWith("///", StringComparison.Ordinal) &&
!lineText.Trim().StartsWith("'''", StringComparison.Ordinal))
{
return(null);
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
foreach (string[] tag in commentTags)
{
list.Items.Add(new DefaultCompletionItem(tag[0])
{
Description = new SimpleDescription(tag[1])
});
}
list.SortItems();
return(list);
}
public static DefaultCompletionItemList ConvertCompletionData(DefaultCompletionItemList result,
IEnumerable <ICompletionEntry> arr,
ExpressionContext context,
IProjectContent projectContent)
{
if (arr == null)
{
return(result);
}
var methodItems = new Dictionary <string, CodeCompletionItem>();
foreach (var o in arr)
{
if (context != null && !context.ShowEntry(o))
{
continue;
}
var method = o as IMethod;
var item = CreateCompletionItem(o, context, projectContent);
if (method != null)
{
CodeCompletionItem codeItem;
if (methodItems.TryGetValue(method.Name, out codeItem))
{
codeItem.Overloads++;
codeItem.Description.OverloadHeaders.Add(item.Description.Header);
continue;
}
}
if (item != null)
{
result.Items.Add(item);
var codeItem = item as CodeCompletionItem;
if (method != null && codeItem != null)
{
methodItems[method.Name] = codeItem;
}
}
}
// Suggested entry (List<int> a = new => suggest List<int>).
if (context.SuggestedItem is SuggestedCodeCompletionItem)
{
result.SuggestedItem = (SuggestedCodeCompletionItem)context.SuggestedItem;
result.Items.Insert(0, result.SuggestedItem);
}
return(result);
}
static void AddTemplates(ITextEditor editor, DefaultCompletionItemList list)
{
if (list == null)
{
return;
}
List <ICompletionItem> snippets = editor.GetSnippets().ToList();
snippets.RemoveAll(item => !FitsToContext(item, list.Items));
list.Items.RemoveAll(item => item.Image == ClassBrowserIconService.Keyword && snippets.Exists(i => i.Text == item.Text));
list.Items.AddRange(snippets);
list.SortItems();
}
public ICompletionItemList GenerateCompletionList(ITextEditor editor, IProjectContent projectContent)
{
var result = new DefaultCompletionItemList {
InsertSpace = false
};
var delegateSignature = _resolvedReturnType.GetMethods().Find(m => m.Name == "Invoke");
if (delegateSignature != null)
{
result.Items.Add(GenerateCreateNewMember(delegateSignature, _resolveResult));
result.Items.AddRange(GenerateFromCallingClass(projectContent, delegateSignature));
}
return(result);
}
public void ShouldNotFilterIfFilterStrategyIsNull()
{
var notFilteredItems = new DefaultCompletionItemList();
notFilteredItems.Items.Add(new DefaultCompletionItem("some item"));
_completionItemProviderMock.Setup(
provider => provider.GenerateCompletionList(It.IsAny <ITextEditor>(), It.IsAny <IProjectContent>()))
.Returns(notFilteredItems);
_cSharpCompletionBinding.FilterStrategy = null;
var textEditorMock = new Mock <ITextEditor>();
_cSharpCompletionBinding.CtrlSpace(textEditorMock.Object);
textEditorMock.Verify(editor => editor.ShowCompletionWindow(It.Is <ICompletionItemList>(list => list.Items.Single().Text == "some item")));
}
public void ProvidesUsingCompletion()
{
var textEditorMock = CreateTextEditorMock(@"using", @"using".Length);
var defaultCompletionItemList = new DefaultCompletionItemList();
defaultCompletionItemList.Items.Add(new NamespaceCompletionItem(new NamespaceEntry("System")));
_completionItemProviderMock.Setup(
provider => provider.GenerateCompletionList(It.IsAny <ITextEditor>(), It.IsAny <IProjectContent>()))
.Returns(defaultCompletionItemList);
_completionItemProviderFactoryMock.Setup(
factory => factory.Create(It.IsAny <LanguageProperties>(), ExpressionContext.Namespace, It.IsAny <IProjectContent>()))
.Returns(_completionItemProviderMock.Object);
_cSharpCompletionBinding.HandleKeyPress(textEditorMock.Object, ' ', _projectContent);
textEditorMock.Verify(editor => editor.ShowCompletionWindow(It.Is <ICompletionItemList>(list => list.Items.Single().Text == "System")));
}
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
CompletionInfo result = context.GetCompletionItems(
editor.FileName,
editor.Caret.Offset,
editor.Document.Text,
memberCompletion);
var itemList = new DefaultCompletionItemList();
if (result != null)
{
var completionDetailsProvider = new CompletionEntryDetailsProvider(
context,
editor.FileName,
editor.Caret.Offset);
itemList.Items.AddRange(result.entries.Select(entry => new TypeScriptCompletionItem(entry, completionDetailsProvider)));
itemList.SortItems();
}
return(itemList);
}
/// <summary>
/// Starts the command
/// </summary>
public override void Run()
{
ITextEditor editor = SD.GetActiveViewContentService <ITextEditor>();
if (editor == null)
{
return;
}
CodeSnippetGroup group = SnippetManager.Instance.FindGroup(Path.GetExtension(editor.FileName));
if (group == null)
{
return;
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
list.Items.AddRange(group.Snippets.Where(i => i.HasSelection).Select(item => item.CreateCompletionItem(editor)));
new CodeSnippetCompletionWindow(editor, list).Show();
}
/// <summary>
/// Starts the command
/// </summary>
public override void Run()
{
ICodeEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ICodeEditorProvider;
if (provider == null)
{
return;
}
CodeSnippetGroup group = SnippetManager.Instance.FindGroup(Path.GetExtension(provider.TextEditor.FileName));
if (group == null)
{
return;
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
list.Items.AddRange(group.Snippets.Where(i => i.HasSelection).Select(item => item.CreateCompletionItem(provider.TextEditor)));
new CodeSnippetCompletionWindow(provider.TextEditor, list).Show();
}
bool ShowCompletion(ITextEditor editor, char completionChar, bool ctrlSpace)
{
CSharpCompletionContext completionContext;
if (fileContent == null)
{
completionContext = CSharpCompletionContext.Get(editor);
}
else
{
completionContext = CSharpCompletionContext.Get(editor, context, currentLocation, fileContent);
}
if (completionContext == null)
{
return(false);
}
int caretOffset;
if (fileContent == null)
{
caretOffset = editor.Caret.Offset;
currentLocation = editor.Caret.Location;
}
else
{
caretOffset = completionContext.Document.GetOffset(currentLocation);
}
var completionFactory = new CSharpCompletionDataFactory(completionContext, new CSharpResolver(completionContext.TypeResolveContextAtCaret));
CSharpCompletionEngine cce = new CSharpCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(completionContext.Compilation.GetProject());
cce.FormattingPolicy = formattingOptions.OptionsContainer.GetEffectiveOptions();
cce.EolMarker = DocumentUtilities.GetLineTerminator(completionContext.Document, currentLocation.Line);
cce.IndentString = editor.Options.IndentationString;
int startPos, triggerWordLength;
IEnumerable <ICompletionData> completionData;
if (ctrlSpace)
{
if (!cce.TryGetCompletionWord(caretOffset, out startPos, out triggerWordLength))
{
startPos = caretOffset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
completionData = completionData.Concat(cce.GetImportCompletionData(startPos));
}
else
{
startPos = caretOffset;
if (char.IsLetterOrDigit(completionChar) || completionChar == '_')
{
if (startPos > 1 && char.IsLetterOrDigit(completionContext.Document.GetCharAt(startPos - 2)))
{
return(false);
}
completionData = cce.GetCompletionData(startPos, false);
startPos--;
triggerWordLength = 1;
}
else
{
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
list.Items.AddRange(FilterAndAddTemplates(editor, completionData.Cast <ICompletionItem>().ToList()));
if (list.Items.Count > 0 && (ctrlSpace || cce.AutoCompleteEmptyMatch))
{
list.SortItems();
list.PreselectionLength = caretOffset - startPos;
list.PostselectionLength = Math.Max(0, startPos + triggerWordLength - caretOffset);
list.SuggestedItem = list.Items.FirstOrDefault(i => i.Text == cce.DefaultCompletionString);
editor.ShowCompletionWindow(list);
return(true);
}
if (!ctrlSpace)
{
// Method Insight
var pce = new CSharpParameterCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var newInsight = pce.GetParameterDataProvider(caretOffset, completionChar) as CSharpMethodInsight;
if (newInsight != null && newInsight.items.Count > 0)
{
newInsight.UpdateHighlightedParameter(pce);
newInsight.Show();
return(true);
}
}
return(false);
}
protected virtual void InitializeCompletionItemList(DefaultCompletionItemList list)
{
list.SortItems();
}
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
DefaultCompletionItemList result = new DefaultCompletionItemList();
result.InsertSpace = true;
// delegate { }
result.Items.Add(new DelegateCompletionItem("delegate { };", 3,
"${res:CSharpBinding.InsertAnonymousMethod}"));
CSharpAmbience ambience = new CSharpAmbience();
// get eventHandler type name incl. type argument list
ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList | ConversionFlags.UseFullyQualifiedTypeNames;
string eventHandlerFullyQualifiedTypeName = ambience.Convert(resolvedReturnType);
ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList;
string eventHandlerTypeName = ambience.Convert(resolvedReturnType);
// retrieve Invoke method from resolvedReturnType instead of resolvedClass to get a method where
// type arguments are substituted.
IMethod invoke = resolvedReturnType.GetMethods().Find(delegate(IMethod m) { return(m.Name == "Invoke"); });
StringBuilder parameterString = new StringBuilder();
if (invoke != null)
{
// build the parameter string
for (int i = 0; i < invoke.Parameters.Count; ++i)
{
if (i > 0)
{
parameterString.Append(", ");
}
parameterString.Append(ambience.Convert(invoke.Parameters[i]));
}
// delegate(object sender, EventArgs e) { };
StringBuilder anonMethodWithParametersBuilder =
new StringBuilder("delegate(").Append(parameterString.ToString()).Append(") { };");
result.Items.Add(new DelegateCompletionItem(anonMethodWithParametersBuilder.ToString(), 3,
"${res:CSharpBinding.InsertAnonymousMethodWithParameters}"));
// new EventHandler(ClassName_EventName);
IClass callingClass = resolveResult.CallingClass;
bool inStatic = false;
if (resolveResult.CallingMember != null)
{
inStatic = resolveResult.CallingMember.IsStatic;
}
// ...build the new handler name...
string newHandlerName = BuildHandlerName();
if (newHandlerName == null)
{
MemberResolveResult mrr = resolveResult as MemberResolveResult;
IEvent eventMember = (mrr != null ? mrr.ResolvedMember as IEvent : null);
newHandlerName =
((callingClass != null) ? callingClass.Name : "callingClass")
+ "_"
+ ((eventMember != null) ? eventMember.Name : "eventMember");
}
// ...build the completion text...
StringBuilder newHandlerTextBuilder = new StringBuilder("new ").Append(eventHandlerTypeName).Append("(");
newHandlerTextBuilder.Append(newHandlerName).Append(");");
// ...build the optional new method text...
StringBuilder newHandlerCodeBuilder = new StringBuilder();
newHandlerCodeBuilder.AppendLine().AppendLine();
if (inStatic)
{
newHandlerCodeBuilder.Append("static ");
}
newHandlerCodeBuilder.Append(ambience.Convert(invoke.ReturnType)).Append(" ").Append(newHandlerName);
newHandlerCodeBuilder.Append("(").Append(parameterString.ToString()).AppendLine(")");
newHandlerCodeBuilder.AppendLine("{");
newHandlerCodeBuilder.AppendLine("throw new NotImplementedException();");
newHandlerCodeBuilder.Append("}");
// ...and add it to the completionData.
result.Items.Add(new NewEventHandlerCompletionItem(
newHandlerTextBuilder.ToString(),
2 + newHandlerName.Length,
newHandlerName.Length,
"new " + eventHandlerFullyQualifiedTypeName +
"(" + newHandlerName + StringParser.Parse(")\n${res:CSharpBinding.GenerateNewHandlerInstructions}\n")
+ CodeCompletionItem.ConvertDocumentation(resolvedClass.Documentation),
resolveResult,
newHandlerCodeBuilder.ToString()
));
if (callingClass != null)
{
foreach (IMethod method in callingClass.DefaultReturnType.GetMethods())
{
if (inStatic && !method.IsStatic)
{
continue;
}
if (!method.IsAccessible(callingClass, true))
{
continue;
}
if (method.Parameters.Count != invoke.Parameters.Count)
{
continue;
}
// check return type compatibility:
if (!MemberLookupHelper.ConversionExists(method.ReturnType, invoke.ReturnType))
{
continue;
}
bool ok = true;
for (int i = 0; i < invoke.Parameters.Count; i++)
{
if (!MemberLookupHelper.ConversionExists(invoke.Parameters[i].ReturnType, method.Parameters[i].ReturnType))
{
ok = false;
break;
}
}
if (ok)
{
result.Items.Add(new CodeCompletionItem(method));
}
}
}
}
result.SortItems();
return(result);
}
