public async Task <CodeCompletionResults> CodeCompleteAtAsync(ISourceFile sourceFile, int index, int line, int column, List <UnsavedFile> unsavedFiles, char previousChar, string filter)
{
var result = new CodeCompletionResults();
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.Completions.Add(newCompletion);
}
}
result.Contexts = CompletionContext.AnyType;
}
return(result);
}
public override async Task <CodeCompletionResults> CodeCompleteAtAsync(IEditor editor, int index, int line, int column, List <UnsavedFile> unsavedFiles, char lastChar, string filter = "")
{
var results = new CodeCompletionResults();
string text = string.Empty;
await Dispatcher.UIThread.InvokeAsync(() =>
{
text = editor.Document.Text;
});
var completionSet = engine.GetCompletions(metaData, text, index);
if (completionSet != null)
{
foreach (var completion in completionSet.Completions)
{
results.Completions.Add(new CodeCompletionData(completion.DisplayText, completion.InsertText, completion.RecommendedCursorOffset)
{
BriefComment = completion.Description,
Kind = FromAvaloniaCompletionKind(completion.Kind),
RecommendImmediateSuggestions = completion.InsertText.Contains("=") || completion.InsertText.EndsWith('.')
});
}
}
results.Contexts = CompletionContext.AnyType;
return(await Task.FromResult(results));
}
public void SetCursor(int index, int line, int column, List <UnsavedFile> unsavedFiles)
{
if (!intellisenseControl.IsVisible)
{
_requestingData = true;
intellisenseQueryRunner.InvokeAsync(() =>
{
CodeCompletionResults result = null;
intellisenseJobRunner.InvokeAsync(() =>
{
var task = languageService.CodeCompleteAtAsync(file, index, line, column, unsavedFiles);
task.Wait();
result = task.Result;
}).Wait();
Dispatcher.UIThread.InvokeAsync(() =>
{
SetCompletionData(result);
_requestingData = false;
UpdateFilter(editor.CaretOffset, false);
intellisenseControl.IsVisible = !_hidden;
});
});
}
}
private void SetCompletionData(CodeCompletionResults completionData)
{
if (_shell.DebugMode)
{
_console.WriteLine(completionData.Contexts.ToString());
}
if (!completionData.Contexts.HasFlag(CompletionContext.NaturalLanguage) && (completionData.Contexts != CompletionContext.Unexposed || completionData.Contexts == CompletionContext.Unknown))
{
if (IncludeSnippets && !(completionData.Contexts.HasFlag(CompletionContext.ArrowMemberAccess) || completionData.Contexts.HasFlag(CompletionContext.DotMemberAccess)))
{
InsertSnippets(completionData.Completions);
}
foreach (var result in completionData.Completions)
{
CompletionDataViewModel currentCompletion = null;
currentCompletion = unfilteredCompletions.BinarySearch(c => c.Title, result.Suggestion);
if (currentCompletion == null)
{
unfilteredCompletions.Add(new CompletionDataViewModel(result));
}
else
{
currentCompletion.Overloads++;
}
}
}
}
public async Task <CodeCompletionResults> DoCompletionRequestAsync(int index, int line, int column)
{
CodeCompletionResults results = null;
var completions = await LanguageService.CodeCompleteAtAsync(ProjectFile, index, line, column, UnsavedFiles.ToList());
results = completions;
return(results);
}
private void SetCompletionData(CodeCompletionResults completionData)
{
if (_studio.DebugMode)
{
_console.WriteLine(completionData.Contexts.ToString());
}
if (completionData.StartOffset.HasValue)
{
_recommendedInsertionOffset = completionData.StartOffset;
}
else
{
_recommendedInsertionOffset = null;
}
if (!completionData.Contexts.HasFlag(CompletionContext.NaturalLanguage) && (completionData.Contexts != CompletionContext.Unexposed || completionData.Contexts == CompletionContext.Unknown))
{
if (IncludeSnippets && !(completionData.Contexts.HasFlag(CompletionContext.ArrowMemberAccess) || completionData.Contexts.HasFlag(CompletionContext.DotMemberAccess)))
{
InsertSnippets(completionData.Completions);
}
recommendedCompletion = null;
foreach (var result in completionData.Completions)
{
CompletionDataViewModel currentCompletion = null;
currentCompletion = unfilteredCompletions.BinarySearch(c => c.FilterText, result.FilterText);
if (currentCompletion == null)
{
currentCompletion = new CompletionDataViewModel(result);
unfilteredCompletions.Add(currentCompletion);
}
else
{
currentCompletion.Overloads++;
}
if (result.SelectionBehavior != CompletionItemSelectionBehavior.Default)
{
if (recommendedCompletion == null || (recommendedCompletion != null && result.Priority > recommendedCompletion.Priority))
{
recommendedCompletion = currentCompletion;
}
}
}
}
}
private void SetCompletionData(CodeCompletionResults completionData)
{
unfilteredCompletions.Clear();
foreach (var result in completionData.Completions)
{
CompletionDataViewModel currentCompletion = null;
currentCompletion = unfilteredCompletions.BinarySearch(c => c.Title, result.Suggestion);
if (currentCompletion == null)
{
unfilteredCompletions.Add(CompletionDataViewModel.Create(result));
}
else
{
currentCompletion.Overloads++;
}
}
}
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);
}
public async Task <CodeCompletionResults> CodeCompleteAtAsync(ISourceFile file, int index, int line, int column,
List <UnsavedFile> unsavedFiles, 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);
var completionResults = translationUnit.CodeCompleteAt(file.Location, line, column, clangUnsavedFiles.ToArray(),
CodeCompleteFlags.IncludeBriefComments | CodeCompleteFlags.IncludeMacros | CodeCompleteFlags.IncludeCodePatterns);
completionResults.Sort();
result.Contexts = (CompletionContext)completionResults.Contexts;
foreach (var codeCompletion in completionResults.Results)
{
var typedText = string.Empty;
var hint = string.Empty;
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))
{
result.Completions.Add(new CodeCompletionData
{
Suggestion = typedText,
Priority = codeCompletion.CompletionString.Priority,
Kind = FromClangKind(codeCompletion.CursorKind),
Hint = hint,
BriefComment = codeCompletion.CompletionString.BriefComment
});
}
}
completionResults.Dispose();
});
return(result);
}
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 void SetCursor(int index, int line, int column, List <UnsavedFile> unsavedFiles, bool canUpdateSignature = true)
{
if (_lastIndex != index)
{
_lastIndex = index;
if (canUpdateSignature)
{
UpdateActiveParameterAndVisibility();
}
if (!intellisenseControl.IsVisible)
{
unfilteredCompletions.Clear();
if (_shell.DebugMode)
{
_console.WriteLine("Set Cursor");
}
_requestingData = true;
char previousChar = '\0';
if (index >= 1)
{
previousChar = editor.Document.GetCharAt(index - 1);
}
intellisenseQueryRunner.InvokeAsync(() =>
{
CodeCompletionResults result = null;
intellisenseJobRunner.InvokeAsync(() =>
{
if (_shell.DebugMode)
{
_console.WriteLine($"Query Language Service {index}, {line}, {column}");
}
var task = languageService.CodeCompleteAtAsync(editor, index, line, column, unsavedFiles, previousChar);
task.Wait();
result = task.Result;
}).Wait();
if (result != null)
{
Dispatcher.UIThread.InvokeAsync(() =>
{
if (_shell.DebugMode)
{
_console.WriteLine($"Set Completion Data {_hidden}");
}
SetCompletionData(result);
_requestingData = false;
if (unfilteredCompletions.Count > 0)
{
UpdateFilter(editor.CaretOffset, false);
intellisenseControl.IsVisible = !_hidden;
}
else
{
_hidden = true;
}
});
}
});
}
else
{
UpdateFilter(editor.CaretOffset, false);
}
}
}
public async Task<CodeCompletionResults> DoCompletionRequestAsync(int line, int column)
{
CodeCompletionResults results = null;
var completions = await LanguageService.CodeCompleteAtAsync(ProjectFile, line, column, UnsavedFiles.ToList());
results = new CodeCompletionResults { Completions = completions };
return results;
}
