public IReadOnlyList <ISymbol> GetRecommendedSymbols(DocumentId documentId, int position)
{
var document = CurrentSolution.GetDocument(documentId);
var semanticModel = document.GetSemanticModelAsync().Result;
return(Recommender.GetRecommendedSymbolsAtPosition(semanticModel, position, this).ToArray());
}
public async Task <IActionResult> AutoComplete([FromBody] Request request)
{
_workspace.EnsureBufferUpdated(request);
var completions = Enumerable.Empty <AutoCompleteResponse>();
var document = _workspace.GetDocument(request.FileName);
if (document != null)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
completions = symbols.Select(MakeAutoCompleteResponse);
}
else
{
return(new HttpNotFoundResult());
}
return(new ObjectResult(completions));
}
public async static Task <IEnumerable <object> > GetAutpocompletionFor(string code, int position)
{
//e:\dev\roslyn\omnisharp-roslyn\src\omnisharp.roslyn.csharp\services\intellisense\intellisenseservice.cs
code = @"class Script
{
static void Main()
{
var test = ""ttt"";
System.Console.WriteLine($""Hello World!{test.Ends";
position = 103;
position = 128 + 4;
var completions = new HashSet <string>();
var workspace = new AdhocWorkspace();
//var workspace1 = new AdhocWorkspace();
//InitWorkspace(workspace, code, position);
string projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var systemCore = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
var references = new[] { mscorlib, systemCore };
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp, metadataReferences: references);
var newProject = workspace.AddProject(projectInfo);
var sourceText = SourceText.From(code);
var newDocument = workspace.AddDocument(newProject.Id, "NewFile7.cs", sourceText);
foreach (var project in workspace.CurrentSolution.Projects)
{
foreach (var document in project.Documents)
{
var model = document.GetSemanticModelAsync().Result;
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, workspace).ToArray();
foreach (var symbol in symbols.Where(s => s.Name.StartsWith("", StringComparison.OrdinalIgnoreCase)))
{
completions.Add(symbol.Name);
}
}
}
var result = completions.Distinct().OrderBy(x => x.ToLower());
result.ToList().ForEach(x => System.Console.WriteLine(x));
return(result);
//return completions
// .OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(wordToComplete))
// .ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(wordToComplete))
// .ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(wordToComplete))
// .ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(wordToComplete))
// .ThenBy(c => c.CompletionText);
}
public IReadOnlyList <ISymbol> GetRecommendedSymbols(DocumentId documentId, int position)
{
var document = CurrentSolution.GetDocument(documentId);
return(ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
var semanticModel = await document.GetSemanticModelAsync().ConfigureAwait(true);
var result = Recommender.GetRecommendedSymbolsAtPosition(semanticModel, position, this);
return result.ToArray();
}).Join());
}
public async Task <CompletionResult[]> GetCompletionsAsync(CompletionRequest request, string code)
{
var workspace = new AdhocWorkspace();
var projectName = RandomString(6, "Project");
var assemblyName = RandomString(6, "Assembly");
var documentName = RandomString(6, "Document");
var project = workspace.CurrentSolution.AddProject(projectName, assemblyName, LanguageNames.CSharp);
// We need to reference assemblies that the code relies on.
var references = GetMetadataReferences();
project = project.WithMetadataReferences(references);
var document = project.AddDocument(documentName, SourceText.From(code));
var text = await document.GetTextAsync();
var position = text.Lines.GetPosition(new LinePosition(request.Line, request.Character));
var model = await document.GetSemanticModelAsync();
var completions = new List <CompletionResult>();
AddKeywords(workspace, completions, model, position, request.WantKind, request.WordToComplete);
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, workspace);
foreach (var symbol in symbols.Where(s => s.Name.IsValidCompletionFor(request.WordToComplete)))
{
if (request.WantSnippet)
{
foreach (var completion in MakeSnippetedResponses(request, symbol))
{
completions.Add(completion);
}
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
return(completions
.OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(request.WordToComplete))
.ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(request.WordToComplete))
.ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(request.WordToComplete))
.ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(request.WordToComplete))
.ThenBy(c => c.CompletionText)
.ToArray());
}
public async Task <IActionResult> AutoComplete([FromBody] AutoCompleteRequest request)
{
_workspace.EnsureBufferUpdated(request);
var completions = new List <AutoCompleteResponse>();
var documents = _workspace.GetDocuments(request.FileName);
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
var context = CSharpSyntaxContext.CreateContext(_workspace, model, position);
var keywordHandler = new KeywordContextHandler();
var keywords = keywordHandler.Get(context, model, position);
foreach (var keyword in keywords)
{
completions.Add(new AutoCompleteResponse
{
CompletionText = keyword,
DisplayText = keyword,
Snippet = keyword
});
}
foreach (var symbol in symbols.Where(s => s.Name.StartsWith(request.WordToComplete, StringComparison.OrdinalIgnoreCase)))
{
if (request.WantSnippet)
{
completions.AddRange(MakeSnippetedResponses(request, symbol));
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
}
return(new ObjectResult(completions));
}
public async Task <IEnumerable <AutoCompleteResponse> > Handle(AutoCompleteRequest request)
{
var documents = _workspace.GetDocuments(request.FileName);
var wordToComplete = request.WordToComplete;
var completions = new HashSet <AutoCompleteResponse>();
foreach (var document in documents)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
AddKeywords(completions, model, position, request.WantKind, wordToComplete);
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
foreach (var symbol in symbols.Where(s => s.Name.IsValidCompletionFor(wordToComplete)))
{
if (request.WantSnippet)
{
foreach (var completion in MakeSnippetedResponses(request, symbol))
{
completions.Add(completion);
}
}
else
{
completions.Add(MakeAutoCompleteResponse(request, symbol));
}
}
}
return(completions
.OrderByDescending(c => c.CompletionText.IsValidCompletionStartsWithExactCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsValidCompletionStartsWithIgnoreCase(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsCamelCaseMatch(wordToComplete))
.ThenByDescending(c => c.CompletionText.IsSubsequenceMatch(wordToComplete))
.ThenBy(c => c.CompletionText));
}
protected override Task <IEnumerable <ISymbol> > GetSymbolsWorker(AbstractSyntaxContext context, int position, OptionSet options, CancellationToken cancellationToken)
{
return(Task.FromResult(Recommender.GetRecommendedSymbolsAtPosition(context.SemanticModel, position, context.Workspace, options, cancellationToken)));
}
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var semanticModel = ctx.SemanticModel;
var result = new List <CompletionData> ();
if (info.TriggerCharacter == ' ')
{
var newExpression = ObjectCreationContextHandler.GetObjectCreationNewExpression(ctx.SyntaxTree, completionContext.Position, cancellationToken);
if (newExpression == null && info.CompletionTriggerReason == CompletionTriggerReason.CharTyped && !ctx.LeftToken.IsKind(SyntaxKind.EqualsToken) && !ctx.LeftToken.IsKind(SyntaxKind.EqualsEqualsToken))
{
return(Enumerable.Empty <CompletionData> ());
}
completionResult.AutoCompleteEmptyMatch = false;
}
var parent = ctx.TargetToken.Parent;
bool isInAttribute = ctx.CSharpSyntaxContext.IsAttributeNameContext;
bool isInBaseList = parent != null && parent.IsKind(SyntaxKind.BaseList);
bool isInUsingDirective = parent != null && parent.Parent != null && parent.Parent.IsKind(SyntaxKind.UsingDirective) && !parent.IsKind(SyntaxKind.QualifiedName);
var isInQuery = ctx.CSharpSyntaxContext.IsInQuery;
var completionDataLookup = new Dictionary <Tuple <string, SymbolKind>, ISymbolCompletionData> ();
bool isInCatchTypeExpression = parent.IsKind(SyntaxKind.CatchDeclaration) ||
parent.IsKind(SyntaxKind.QualifiedName) && parent != null && parent.Parent.IsKind(SyntaxKind.CatchDeclaration);
Action <ISymbolCompletionData> addData = d => {
var key = Tuple.Create(d.DisplayText, d.Symbol.Kind);
ISymbolCompletionData data;
if (completionDataLookup.TryGetValue(key, out data))
{
data.AddOverload(d);
return;
}
completionDataLookup.Add(key, d);
result.Add(d);
};
var completionCategoryLookup = new Dictionary <string, CompletionCategory> ();
foreach (var symbol in Recommender.GetRecommendedSymbolsAtPosition(semanticModel, completionContext.Position, engine.Workspace, null, cancellationToken))
{
if (symbol.Kind == SymbolKind.NamedType)
{
if (isInAttribute)
{
var type = (ITypeSymbol)symbol;
if (type.IsAttribute())
{
var v = type.Name.Substring(0, type.Name.Length - "Attribute".Length);
var needsEscaping = SyntaxFacts.GetKeywordKind(v) != SyntaxKind.None;
needsEscaping = needsEscaping || (isInQuery && SyntaxFacts.IsQueryContextualKeyword(SyntaxFacts.GetContextualKeywordKind(v)));
if (!needsEscaping)
{
addData(engine.Factory.CreateSymbolCompletionData(this, symbol, v));
continue;
}
}
}
if (isInBaseList)
{
var type = (ITypeSymbol)symbol;
if (type.IsSealed || type.IsStatic)
{
continue;
}
}
if (isInCatchTypeExpression)
{
var type = (ITypeSymbol)symbol;
if (!IsException(type))
{
continue;
}
}
}
if (isInUsingDirective && symbol.Kind != SymbolKind.Namespace)
{
continue;
}
var newData = engine.Factory.CreateSymbolCompletionData(this, symbol, symbol.Name.EscapeIdentifier(isInQuery));
var categorySymbol = (ISymbol)symbol.ContainingType ?? symbol.ContainingNamespace;
if (categorySymbol != null)
{
CompletionCategory category;
var key = categorySymbol.ToDisplayString();
if (!completionCategoryLookup.TryGetValue(key, out category))
{
completionCategoryLookup [key] = category = engine.Factory.CreateCompletionDataCategory(categorySymbol);
}
newData.CompletionCategory = category;
}
addData(newData);
}
return(result);
}
public async Task <CompletionResult> GetCompletionList(WorkspaceRequest request, Budget budget)
{
budget ??= new TimeBudget(TimeSpan.FromSeconds(defaultBudgetInSeconds));
var package = await _packageFinder.Find <ICreateWorkspace>(request.Workspace.WorkspaceType);
var workspace = await request.Workspace.InlineBuffersAsync();
var sourceFiles = workspace.GetSourceFiles();
// get project and ensure the solution is up-to-date
var(_compilation, project) = await package.GetCompilationForLanguageServices(
sourceFiles,
GetSourceCodeKind(request),
GetUsings(request.Workspace),
budget);
var documents = project.Documents.ToList();
var solution = project.Solution;
// get most up-to-date document
var file = workspace.GetFileFromBufferId(request.ActiveBufferId);
var selectedDocumentId = documents.First(doc => doc.IsMatch(file)).Id;
var selectedDocument = solution.GetDocument(selectedDocumentId);
var service = CompletionService.GetService(selectedDocument);
var(_line, _column, absolutePosition) = workspace.GetTextLocation(request.ActiveBufferId);
var completionList = await service.GetCompletionsAsync(selectedDocument, absolutePosition);
var semanticModel = await selectedDocument.GetSemanticModelAsync();
var diagnostics = DiagnosticsExtractor.ExtractSerializableDiagnosticsFromSemanticModel(request.ActiveBufferId, budget, semanticModel, workspace);
var symbols = Recommender.GetRecommendedSymbolsAtPosition(
semanticModel,
absolutePosition,
solution.Workspace);
var symbolToSymbolKey = new Dictionary <(string, int), ISymbol>();
foreach (var symbol in symbols)
{
var key = (symbol.Name, (int)symbol.Kind);
if (!symbolToSymbolKey.ContainsKey(key))
{
symbolToSymbolKey[key] = symbol;
}
}
if (completionList == null)
{
return(new CompletionResult(requestId: request.RequestId, diagnostics: diagnostics));
}
var completionItems = completionList.Items
.Where(i => i != null)
.Select(item => item.ToModel(symbolToSymbolKey, selectedDocument));
return(new CompletionResult(completionItems
.Deduplicate()
.ToArray(),
requestId: request.RequestId,
diagnostics: diagnostics));
}
