public static async Task <Hover> Handle(CSharpContext context, string code, int line, int column)
{
var _document = context.WithText(code);
var position = context.GetPosition(line, column);
var semanticModel = await _document.GetSemanticModelAsync();
var symbol = await SymbolFinder.FindSymbolAtPositionAsync(semanticModel, position, context.Workspace);
if (symbol != null)
{
var type = symbol.Kind == SymbolKind.NamedType ?
symbol.ToDisplayString() :
symbol.ToMinimalDisplayString(semanticModel, position);
var documentation = DocumentationConverter.ConvertDocumentation(symbol.GetDocumentationCommentXml(), "\r\n");
var structuredDocumentation = DocumentationConverter.GetStructuredDocumentation(symbol, "\r\n");
return(new Hover
{
contents = new List <MarkedString>
{
new MarkedString {
value = type, language = "csharp"
},
new MarkedString {
value = string.IsNullOrEmpty(documentation) ? structuredDocumentation.SummaryText : documentation
},
}
});
}
return(null);
}
public static async Task <List <TextEdit> > Handle(CSharpContext context, string code)
{
var _document = context.WithText(code, false);
var doc = _document.WithText(SourceText.From(code.Trim(' ', '\r', 'n', '\t')));
var newDocument = await Formatter.FormatAsync(doc, _document.Project.Solution.Workspace.Options
.WithChangedOption(CSharpFormattingOptions.IndentBlock, true)
.WithChangedOption(CSharpFormattingOptions.IndentBraces, false)
.WithChangedOption(FormattingOptions.UseTabs, "C#", false)
.WithChangedOption(FormattingOptions.SmartIndent, "C#", FormattingOptions.IndentStyle.Smart));
var changes = await newDocument.GetTextChangesAsync(_document);
var res = changes.Select(x => new TextEdit
{
text = x.NewText,
range = SpanToRange(x.Span, x.NewText, context.SourceText)
})
.ToList();
return(res);
}
public static async Task <List <MarkerData> > Handle(CSharpContext context, string code)
{
var document = context.WithText(code);
var semanticModel = await document.GetSemanticModelAsync();
var diagnostics = semanticModel.GetDiagnostics();
//diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => new { x.Severity, message = x.GetMessage(), ls = x.Location.GetLineSpan() })
return(diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x =>
{
var ls = x.Location.GetLineSpan();
return new MarkerData
{
message = x.GetMessage(),
severity = Severity.Error,
startLineNumber = ls.StartLinePosition.Line - context.StartLine + 1,
startColumn = ls.StartLinePosition.Character + 1,
endLineNumber = ls.EndLinePosition.Line - context.StartLine + 1,
endColumn = ls.EndLinePosition.Character + 1
};
}).ToList());
}
public static async Task <List <CompletionItem> > Handle(CSharpContext context, string code, int line, int column)
{
var _document = context.WithText(code);
var position = context.GetPosition(line, column);
var service = Microsoft.CodeAnalysis.Completion.CompletionService.GetService(_document);
var completionList = service.GetCompletionsAsync(_document, position).Result;
var completions = new HashSet <AutoCompleteResponse>();
if (completionList != null)
{
// Only trigger on space if Roslyn has object creation items
//if (request.TriggerCharacter == " " && !completionList.Items.Any(i => i.IsObjectCreationCompletionItem()))
//{
// return completions;
//}
// get recommended symbols to match them up later with SymbolCompletionProvider
var semanticModel = await _document.GetSemanticModelAsync();
var recommendedSymbols = await Microsoft.CodeAnalysis.Recommendations.Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, position, context.Workspace);
var isSuggestionMode = completionList.SuggestionModeItem != null;
foreach (var item in completionList.Items)
{
var completionText = item.DisplayText;
//if (completionText.IsValidCompletionFor(wordToComplete))
{
var symbols = await item.GetCompletionSymbolsAsync(recommendedSymbols, _document);
if (symbols.Any())
{
foreach (var symbol in symbols)
{
if (context.Types != null && symbol.Kind != SymbolKind.Namespace)
{
var name = symbol.ContainingType != null
? symbol.ContainingType.ToDisplayString()
: symbol.ToString();
var allowed = context.Types.Any(y => name.Like(y));
if (!allowed)
{
continue;
}
}
if (item.UseDisplayTextAsCompletionText())
{
completionText = item.DisplayText;
}
else if (item.TryGetInsertionText(out var insertionText))
{
completionText = insertionText;
}
else
{
completionText = symbol.Name;
}
if (symbol != null)
{
//if (request.WantSnippet)
//{
// foreach (var completion in MakeSnippetedResponses(request, symbol, completionText, isSuggestionMode))
// {
// completions.Add(completion);
// }
//}
//else
{
completions.Add(MakeAutoCompleteResponse(symbol, completionText, isSuggestionMode));
}
}
}
// if we had any symbols from the completion, we can continue, otherwise it means
// the completion didn't have an associated symbol so we'll add it manually
continue;
}
// for other completions, i.e. keywords, create a simple AutoCompleteResponse
// we'll just assume that the completion text is the same
// as the display text.
var response = new AutoCompleteResponse()
{
CompletionText = item.DisplayText,
DisplayText = item.DisplayText,
Snippet = item.DisplayText,
Kind = item.Tags.First(),
IsSuggestionMode = isSuggestionMode
};
completions.Add(response);
}
}
}
var osr = 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))
.OrderBy(c => c.DisplayText, StringComparer.OrdinalIgnoreCase)
.ThenBy(c => c.CompletionText, StringComparer.OrdinalIgnoreCase);
var completions2 = new Dictionary <string, List <CompletionItem> >();
foreach (var response in osr)
{
var completionItem = new CompletionItem
{
label = response.CompletionText,
detail = !string.IsNullOrEmpty(response.ReturnType) ?
response.DisplayText :
$"{response.ReturnType} {response.DisplayText}",
documentation = response.Description,
kind = (int)GetCompletionItemKind(response.Kind),
insertText = response.CompletionText,
};
if (!completions2.ContainsKey(completionItem.label))
{
completions2[completionItem.label] = new List <CompletionItem>();
}
completions2[completionItem.label].Add(completionItem);
}
var result = new List <CompletionItem>();
foreach (var key in completions2.Keys)
{
var suggestion = completions2[key][0];
var overloadCount = completions2[key].Count - 1;
if (overloadCount > 0)
{
// indicate that there is more
suggestion.detail = $"{suggestion.detail} (+ {overloadCount} overload(s))";
}
result.Add(suggestion);
}
return(result);
}