void ShowCompletionData(ICompletionData[] dataList, string text)
{
string lowerText = text.ToLowerInvariant();
foreach (ICompletionData data in dataList)
{
CodeCompletionData ccd = data as CodeCompletionData;
if (ccd == null)
{
return;
}
string dataText = ccd.Text;
if (dataText.Length >= text.Length)
{
if (dataText.ToLowerInvariant().IndexOf(lowerText) >= 0)
{
if (ccd.Class != null)
{
AddItem(ccd.Class, data.ImageIndex, data.Priority);
}
else if (ccd.Member != null)
{
AddItem(ccd.Member, data.ImageIndex, data.Priority);
}
}
}
}
}
void ShowCompletionData(ICompletionData[] dataList, string text)
{
string lowerText = text.ToLowerInvariant();
foreach (ICompletionData data in dataList)
{
CodeCompletionData ccd = data as CodeCompletionData;
if (ccd == null)
{
return;
}
string dataText = ccd.Text;
int matchType = GetMatchType(text, dataText);
if (matchType >= 0)
{
if (ccd.Class != null)
{
AddItem(ccd.Class, data.ImageIndex, data.Priority, matchType);
}
else if (ccd.Member != null)
{
AddItem(ccd.Member, data.ImageIndex, data.Priority, matchType);
}
}
}
}
public async Task <List <CodeCompletionData> > CodeCompleteAtAsync(ISourceFile sourceFile, int line, int column, List <UnsavedFile> unsavedFiles, string filter)
{
var result = new List <CodeCompletionData>();
var dataAssociation = GetAssociatedData(sourceFile);
var response = await dataAssociation.Solution.Server.AutoComplete(sourceFile.FilePath, unsavedFiles.FirstOrDefault()?.Contents, line, column);
if (response != null)
{
foreach (var completion in response)
{
var newCompletion = new CodeCompletionData()
{
Suggestion = completion.CompletionText,
Priority = 1,
Hint = completion.DisplayText,
BriefComment = completion.Description?.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(),
Kind = FromOmniSharpKind(completion.Kind)
};
if (filter == string.Empty || completion.CompletionText.StartsWith(filter))
{
result.Add(newCompletion);
}
}
}
return(result);
}
void CodeCompletionListViewSelectedItemChanged(object sender, EventArgs e)
{
if (codeCompletionListView != null)
{
ICompletionData data = codeCompletionListView.SelectedCompletionData;
if (showDeclarationWindow && data != null && data.Description != null && data.Description.Length > 0)
{
declarationViewWindow.Description = data.Description;
if (data is O2.External.SharpDevelop.Ascx.CodeCompletionData)
{
lastCodeCompleteData = (O2.External.SharpDevelop.Ascx.CodeCompletionData)data;
if (lastCodeCompleteData.member.notNull())
{
var memberSignature = lastCodeCompleteData.member.str().remove("[DefaultMethod: ").removeLastChar();
declarationViewWindow.Description = (declarationViewWindow.Description + memberSignature).trim();
}
if (lastCodeCompleteData.c.notNull())
{
var classDescription = lastCodeCompleteData.c.str().remove("[DefaultClass: ").removeLastChar().line();
foreach (var method in lastCodeCompleteData.c.Methods)
{
classDescription += " - {0}".info(method.str()).line();
}
declarationViewWindow.Description = (declarationViewWindow.Description + classDescription).trim();
}
}
SetDeclarationViewLocation();
}
else
{
declarationViewWindow.Description = null;
}
}
}
public override bool InsertAction(ICompletionData data, ICSharpCode.TextEditor.TextArea textArea, int insertionOffset, char key)
{
CodeCompletionData ccData = data as CodeCompletionData;
if (IsAttributeCompletion && ccData != null)
{
textArea.Caret.Position = textArea.Document.OffsetToPosition(insertionOffset);
textArea.InsertString(ccData.Text + "=\"\"");
textArea.Caret.Column -= 1;
SharpDevelopTextAreaControl editor = textArea.MotherTextEditorControl as SharpDevelopTextAreaControl;
if (editor != null)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
XamlCompletionDataProvider provider = new XamlCompletionDataProvider();
provider.AllowCompleteExistingExpression = true;
editor.ShowCompletionWindow(provider, '\0');
}
);
}
return(false);
}
else
{
return(base.InsertAction(data, textArea, insertionOffset, key));
}
}
/// <summary>
/// Triggers the authentication flow
/// </summary>
/// <remarks>
/// This returns a boolean to remain compatible with our native
/// implementation - however it always returns true in managed code
/// </remarks>
/// <returns><c>true</c></returns>
public bool Authenticate()
{
this.client.GetAsync(this.codeUri).ContinueWith(async(Task <HttpResponseMessage> prev) =>
{
var message = prev.Result;
var eventData = new CodeCompletionData()
{
http_status = (int)message.StatusCode
};
if (message.StatusCode == HttpStatusCode.OK)
{
var body = await message.Content.ReadAsStringAsync();
var obj = JObject.Parse(body);
eventData.device_code = obj.Value <string>("device_code");
eventData.user_code = obj.Value <string>("user_code");
eventData.interval = obj.Value <int>("interval");
eventData.verification_url = obj.Value <string>("verification_url");
// schedule our polling logic
this.pollTimer = new Timer(PollTimer,
eventData.device_code,
TimeSpan.FromMilliseconds(0),
TimeSpan.FromSeconds(eventData.interval));
}
this.CodeComplete?.Invoke(eventData);
});
// this maintains api compatibility with our native version
// but is technically useless here (since it's always true)
return(true);
}
protected bool ProvideContextCompletion(CodeEditorControl editor, IReturnType expected, char charTyped)
{
if (expected == null)
{
return(false);
}
IClass c = expected.GetUnderlyingClass();
if (c == null)
{
return(false);
}
if (c.ClassType == ClassType.Enum)
{
CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
cdp.ForceNewExpression = true;
ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp);
cache.activationKey = charTyped;
cache.GenerateCompletionData(editor.ActiveViewControl.FileName, editor.ActiveViewControl, charTyped);
ICompletionData[] completionData = cache.CompletionData;
Array.Sort(completionData);
for (int i = 0; i < completionData.Length; i++)
{
CodeCompletionData ccd = completionData[i] as CodeCompletionData;
if (ccd != null && ccd.Class != null)
{
if (ccd.Class.FullyQualifiedName == expected.FullyQualifiedName)
{
cache.DefaultIndex = i;
break;
}
}
}
if (cache.DefaultIndex >= 0)
{
if (charTyped != ' ')
{
cdp.InsertSpace = true;
}
editor.ActiveViewControl.ShowCompletionWindow(cache, charTyped);
return(true);
}
}
return(false);
}
private async Task <List <CodeCompletionData> > CodeCompleteAtAsync(IEditor editor, int index,
List <UnsavedFile> unsavedFiles, string filter = "")
{
var currentUnsavedFile = unsavedFiles.FirstOrDefault(f => f.FileName == editor.SourceFile.FilePath);
var currentFileConts = currentUnsavedFile?.Contents ?? File.ReadAllText(editor.SourceFile.FilePath);
var caretPosition = index;
var completions = await _typeScriptContext.GetCompletionsAtPositionAsync(editor.SourceFile.FilePath, caretPosition);
var editorCompletions = completions.Entries.Select(cc =>
{
var ccData = new CodeCompletionData(cc.Name, cc.Name)
{
Kind = ConvertCodeCompletionKind(cc.Kind),
BriefComment = cc.Name
};
return(ccData);
})
.ToList();
return(editorCompletions);
}
public FieldCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public EnumConstantCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public KeywordCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public PropertyCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public ClassCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
/// <summary>
/// Generates the completion data. This method is called by the text editor control.
/// </summary>
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
List <ICompletionData> completionData = new List <ICompletionData>();
// delegate { }
completionData.Add(new DelegateCompletionData("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(") { };");
completionData.Add(new DelegateCompletionData(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.
completionData.Add(new NewEventHandlerCompletionData(
newHandlerTextBuilder.ToString(),
2 + newHandlerName.Length,
newHandlerName.Length,
"new " + eventHandlerFullyQualifiedTypeName +
"(" + newHandlerName + StringParser.Parse(")\n${res:CSharpBinding.GenerateNewHandlerInstructions}\n")
+ CodeCompletionData.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)
{
completionData.Add(new CodeCompletionData(method));
}
}
}
}
return(completionData.ToArray());
}
public MethodCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
void AddCompletionData(List<ICompletionData> resultList, ArrayList completionData)
{
// var currentCodeCompleteText = "";
// var lenght = textEditor.currentOffset() - startOffset;
// if (lenght >0)
// currentCodeCompleteText = textEditor.get_Text(startOffset,lenght);
// "{0}:{1} = {2}".format(startOffset,lenght , currentCodeCompleteText).debug();
// used to store the method names for grouping overloads
Dictionary<string, CodeCompletionData> nameDictionary = new Dictionary<string, CodeCompletionData>();
// Add the completion data as returned by SharpDevelop.Dom to the
// list for the text editor
foreach (object obj in completionData) {
if (obj is string) {
// namespace names are returned as string
resultList.Add(new DefaultCompletionData((string)obj, "namespace " + obj, 5));
} else if (obj is IClass) {
IClass c = (IClass)obj;
resultList.Add(new CodeCompletionData(c,this));
} else if (obj is IMember) {
IMember m = (IMember)obj;
if (m is IMethod && ((m as IMethod).IsConstructor)) {
// Skip constructors
continue;
}
// if OnlyShowCodeCompleteResulstFromO2Namespace filter for only O2.* namepace
if (OnlyShowCodeCompleteResulstFromO2Namespace && m.DeclaringType.Namespace.starts("O2") == false)
continue;
// NOT WORKING only show items that match currentCodeCompleteText regex
// if (currentCodeCompleteText != "" && m.DotNetName.nregEx(currentCodeCompleteText))
// continue;
//if
// Group results by name and add "(x Overloads)" to the
// description if there are multiple results with the same name.
CodeCompletionData data;
if (nameDictionary.TryGetValue(m.Name, out data)) {
data.AddOverload();
} else {
nameDictionary[m.Name] = data = new CodeCompletionData(m,this);
resultList.Add(data);
}
} else {
// Current ICSharpCode.SharpDevelop.Dom should never return anything else
throw new NotSupportedException();
}
}
}
/// <summary>
/// Generates the completion data. This method is called by the text editor control.
/// </summary>
public override ICompletionData[] GenerateCompletionData(string fileName, EditViewControl textArea, char charTyped)
{
string methodName = this.resolveResult.CallingClass.Name + "_" + this.expression.Trim().Substring(this.expression.Trim().LastIndexOf('.') + 1);
List <ICompletionData> completionData = new List <ICompletionData>();
completionData.Add(new DelegateCompletionData("delegate { };", 3,
"Insert Anonymous Method"));
CSharpAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
IMethod invoke = resolvedClass.SearchMember("Invoke", LanguageProperties.CSharp) as IMethod;
DomRegion r = this.resolveResult.CallingMember.BodyRegion;
DomRegion rm = this.resolveResult.CallingMember.Region;
TextPoint cPos = textArea.Caret.Position;
TextRange trIntened = new TextRange(0, rm.BeginLine - 1, rm.BeginColumn - 1, rm.BeginLine - 1);
string IntendString = textArea.Document.GetRange(trIntened);
int curPos = textArea.Document.PointToIntPos(new TextPoint(0, r.EndLine - 1));
StringBuilder parambuilder = new StringBuilder("(");
if (invoke != null)
{
StringBuilder builder = new StringBuilder("delegate(");
for (int i = 0; i < invoke.Parameters.Count; ++i)
{
if (i > 0)
{
builder.Append(", ");
parambuilder.Append(", ");
}
builder.Append(ambience.Convert(invoke.Parameters[i]));
parambuilder.Append(ambience.Convert(invoke.Parameters[i]));
}
builder.Append(") { };");
parambuilder.Append(")");
string MethodBody = "new " + resolveResult.ResolvedType.Name + "(delegate" + parambuilder + "{ });";
completionData.Add(new DelegateCompletionData(MethodBody, 4,
"delegate " + resolvedClass.FullyQualifiedName + "\n" + CodeCompletionData.GetDocumentation(resolvedClass.Documentation)));
completionData.Add(new DelegateCompletionData(builder.ToString(), 3,
"Insert Anonymous Method With Parameters"));
IClass callingClass = resolveResult.CallingClass;
IClass eventReturnType = invoke.ReturnType.GetUnderlyingClass();
IClass[] eventParameters = new IClass[invoke.Parameters.Count];
for (int i = 0; i < eventParameters.Length; i++)
{
eventParameters[i] = invoke.Parameters[i].ReturnType.GetUnderlyingClass();
if (eventParameters[i] == null)
{
eventReturnType = null;
break;
}
}
if (callingClass != null && eventReturnType != null)
{
bool inStatic = false;
if (resolveResult.CallingMember != null)
{
inStatic = resolveResult.CallingMember.IsStatic;
}
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:
IClass c2 = method.ReturnType.GetUnderlyingClass();
if (c2 == null || !c2.IsTypeInInheritanceTree(eventReturnType))
{
continue;
}
bool ok = true;
for (int i = 0; i < eventParameters.Length; i++)
{
c2 = method.Parameters[i].ReturnType.GetUnderlyingClass();
if (c2 == null || !eventParameters[i].IsTypeInInheritanceTree(c2))
{
ok = false;
break;
}
}
if (ok)
{
completionData.Add(new CodeCompletionData(method));
}
}
}
}
return(completionData.ToArray());
}
/// <summary>
/// Generates the completion data. This method is called by the text editor control.
/// </summary>
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
List <ICompletionData> completionData = new List <ICompletionData>();
completionData.Add(new DelegateCompletionData("new " + resolveResult.ResolvedType.Name + "();", 2,
"delegate " + resolvedClass.FullyQualifiedName + "\n" + CodeCompletionData.GetDocumentation(resolvedClass.Documentation)));
completionData.Add(new DelegateCompletionData("delegate { };", 3,
"${res:CSharpBinding.InsertAnonymousMethod}"));
CSharpAmbience ambience = new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
IMethod invoke = resolvedClass.SearchMember("Invoke", LanguageProperties.CSharp) as IMethod;
if (invoke != null)
{
StringBuilder builder = new StringBuilder("delegate(");
for (int i = 0; i < invoke.Parameters.Count; ++i)
{
if (i > 0)
{
builder.Append(", ");
}
builder.Append(ambience.Convert(invoke.Parameters[i]));
}
builder.Append(") { };");
completionData.Add(new DelegateCompletionData(builder.ToString(), 3,
"${res:CSharpBinding.InsertAnonymousMethodWithParameters}"));
IClass callingClass = resolveResult.CallingClass;
IClass eventReturnType = invoke.ReturnType.GetUnderlyingClass();
IClass[] eventParameters = new IClass[invoke.Parameters.Count];
for (int i = 0; i < eventParameters.Length; i++)
{
eventParameters[i] = invoke.Parameters[i].ReturnType.GetUnderlyingClass();
if (eventParameters[i] == null)
{
eventReturnType = null;
break;
}
}
if (callingClass != null && eventReturnType != null)
{
bool inStatic = false;
if (resolveResult.CallingMember != null)
{
inStatic = resolveResult.CallingMember.IsStatic;
}
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:
IClass c2 = method.ReturnType.GetUnderlyingClass();
if (c2 == null || !c2.IsTypeInInheritanceTree(eventReturnType))
{
continue;
}
bool ok = true;
for (int i = 0; i < eventParameters.Length; i++)
{
c2 = method.Parameters[i].ReturnType.GetUnderlyingClass();
if (c2 == null || !eventParameters[i].IsTypeInInheritanceTree(c2))
{
ok = false;
break;
}
}
if (ok)
{
completionData.Add(new CodeCompletionData(method));
}
}
}
}
return(completionData.ToArray());
}
public ParameterCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public DefaultCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public async Task <CodeCompletionResults> CodeCompleteAtAsync(ISourceFile file, int index, int line, int column,
List <UnsavedFile> unsavedFiles, char lastChar, string filter)
{
var clangUnsavedFiles = new List <ClangUnsavedFile>();
foreach (var unsavedFile in unsavedFiles)
{
clangUnsavedFiles.Add(new ClangUnsavedFile(unsavedFile.FileName, unsavedFile.Contents));
}
var result = new CodeCompletionResults();
await clangAccessJobRunner.InvokeAsync(() =>
{
var translationUnit = GetAndParseTranslationUnit(file, clangUnsavedFiles);
if (translationUnit != null)
{
var completionResults = translationUnit.CodeCompleteAt(file.Location, line, column, clangUnsavedFiles.ToArray(),
CodeCompleteFlags.IncludeBriefComments | CodeCompleteFlags.IncludeMacros | CodeCompleteFlags.IncludeCodePatterns);
completionResults.Sort();
result.Contexts = (CompletionContext)completionResults.Contexts;
if (result.Contexts == CompletionContext.Unexposed && lastChar == ':')
{
result.Contexts = CompletionContext.AnyType; // special case Class::<- here static class member access.
}
foreach (var codeCompletion in completionResults.Results)
{
var typedText = string.Empty;
var hint = string.Empty;
if (codeCompletion.CompletionString.Availability == AvailabilityKind.Available || codeCompletion.CompletionString.Availability == AvailabilityKind.Deprecated)
{
foreach (var chunk in codeCompletion.CompletionString.Chunks)
{
if (chunk.Kind == CompletionChunkKind.TypedText)
{
typedText = chunk.Text;
}
hint += chunk.Text;
switch (chunk.Kind)
{
case CompletionChunkKind.LeftParen:
case CompletionChunkKind.LeftAngle:
case CompletionChunkKind.LeftBrace:
case CompletionChunkKind.LeftBracket:
case CompletionChunkKind.RightAngle:
case CompletionChunkKind.RightBrace:
case CompletionChunkKind.RightBracket:
case CompletionChunkKind.RightParen:
case CompletionChunkKind.Placeholder:
case CompletionChunkKind.Comma:
break;
default:
hint += " ";
break;
}
}
if (filter == string.Empty || typedText.StartsWith(filter))
{
var completion = new CodeCompletionData
{
Suggestion = typedText,
Priority = codeCompletion.CompletionString.Priority,
Kind = FromClangKind(codeCompletion.CursorKind),
Hint = hint,
BriefComment = codeCompletion.CompletionString.BriefComment
};
result.Completions.Add(completion);
if (completion.Kind == CodeCompletionKind.OverloadCandidate)
{
Console.WriteLine("TODO Implement overload candidate.");
}
}
}
}
completionResults.Dispose();
}
});
return(result);
}
void AddCompletionData(List<ICompletionData> resultList, ArrayList completionData)
{
// ReSharper disable CanBeReplacedWithTryCastAndCheckForNull
// used to store the method names for grouping overloads
var nameDictionary = new Dictionary<string, CodeCompletionData>();
// Add the completion data as returned by SharpDevelop.Dom to the
// list for the text editor
foreach (object obj in completionData) {
if (obj is string)
{
// namespace names are returned as string
resultList.Add(new DefaultCompletionData((string)obj, "namespace " + obj, 5));
} else if (obj is IClass)
{
var c = (IClass)obj;
resultList.Add(new CodeCompletionData(c,this));
} else if (obj is IMember)
{
var m = (IMember)obj;
if (m is IMethod && ((m as IMethod).IsConstructor))
{
// Skip constructors
continue;
}
// if OnlyShowCodeCompleteResulstFromO2Namespace filter for only FluentSharp.* namepace
if (OnlyShowCodeCompleteResultsFromO2Namespace && m.DeclaringType.Namespace.starts("FluentSharp") == false)
continue;
// NOT WORKING only show items that match currentCodeCompleteText regex
// if (currentCodeCompleteText != "" && m.DotNetName.nregEx(currentCodeCompleteText))
// continue;
//if
// Group results by name and add "(x Overloads)" to the
// description if there are multiple results with the same name.
CodeCompletionData data;
if (nameDictionary.TryGetValue(m.Name, out data))
{
data.AddOverload(m);
} else {
nameDictionary[m.Name] = data = new CodeCompletionData(m,this);
resultList.Add(data);
}
} else {
// Current ICSharpCode.SharpDevelop.Dom should never return anything else
throw new NotSupportedException();
}
}
// ReSharper restore CanBeReplacedWithTryCastAndCheckForNull
}
public async Task <CodeCompletionResults> CodeCompleteAtAsync(int index, int line, int column, IEnumerable <UnsavedFile> unsavedFiles, char previousChar, string filter)
{
if (_editor.SourceFile is MetaDataFile)
{
return(null);
}
var result = new CodeCompletionResults();
var dataAssociation = GetAssociatedData(_editor);
var workspace = RoslynWorkspace.GetWorkspace(dataAssociation.Solution);
var document = workspace.GetDocument(_editor.SourceFile);
var semanticModel = await document.GetSemanticModelAsync();
var completionService = CompletionService.GetService(document);
var data = await completionService.GetCompletionsAsync(document, index);
if (data != null)
{
var recommendedSymbols = await Microsoft.CodeAnalysis.Recommendations.Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, index, workspace);
foreach (var completion in data.Items)
{
var insertionText = completion.DisplayText;
if (completion.Properties.ContainsKey("InsertionText"))
{
insertionText = completion.Properties["InsertionText"];
}
var selectionBehavior = Languages.CompletionItemSelectionBehavior.Default;
int priority = 0;
if (completion.Rules.SelectionBehavior != Microsoft.CodeAnalysis.Completion.CompletionItemSelectionBehavior.Default)
{
selectionBehavior = (Languages.CompletionItemSelectionBehavior)completion.Rules.SelectionBehavior;
priority = completion.Rules.MatchPriority;
}
if (completion.Properties.ContainsKey("Provider") && completion.Properties["Provider"] == "Microsoft.CodeAnalysis.CSharp.Completion.Providers.SymbolCompletionProvider")
{
var symbols = recommendedSymbols.Where(x => x.Name == completion.Properties["SymbolName"] && (int)x.Kind == int.Parse(completion.Properties["SymbolKind"])).Distinct();
if (symbols != null && symbols.Any())
{
foreach (var symbol in symbols)
{
if (symbol != null)
{
var newCompletion = new CodeCompletionData(symbol.Name, completion.FilterText, insertionText, null, selectionBehavior, priority);
if (completion.Properties.ContainsKey("SymbolKind"))
{
newCompletion.Kind = FromOmniSharpKind(completion.Properties["SymbolKind"]);
}
var xmlDocumentation = symbol.GetDocumentationCommentXml();
if (xmlDocumentation != string.Empty)
{
var docComment = DocumentationComment.From(xmlDocumentation, Environment.NewLine);
newCompletion.BriefComment = docComment.SummaryText;
}
result.Completions.Add(newCompletion);
}
}
}
}
else
{
var newCompletion = new CodeCompletionData(completion.DisplayText, completion.FilterText, insertionText, null, selectionBehavior, priority);
if (completion.Properties.ContainsKey("SymbolKind"))
{
newCompletion.Kind = FromOmniSharpKind(completion.Properties["SymbolKind"]);
}
result.Completions.Add(newCompletion);
}
}
result.Contexts = Languages.CompletionContext.AnyType;
}
return(result);
}
public MacroCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public VariableCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public StructCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
public SnippetCompletionDataViewModel(CodeCompletionData model) : base(model)
{
}
