void Analyze (CompletionEngine engine,SemanticModel model, SyntaxNode node, ISymbol within, List<CompletionData> list, ParameterListSyntax parameterList, ISymbol symbol, HashSet<string> addedSymbols, CancellationToken cancellationToken)
{
var type = CheckParameterList (model, parameterList, symbol, cancellationToken);
if (type == null)
return;
var startType = type;
while (type.SpecialType != SpecialType.System_Object) {
foreach (var member in type.GetMembers ()) {
if (member.IsImplicitlyDeclared || member.IsStatic)
continue;
if (member.IsOrdinaryMethod () || member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property) {
if (member.IsAccessibleWithin (within)) {
var completionData = engine.Factory.CreateCastCompletionData(this, member, node, startType);
if (addedSymbols.Contains (completionData.DisplayText))
continue;
addedSymbols.Add (completionData.DisplayText);
list.Add (completionData);
}
}
}
type = type.BaseType;
}
}
protected override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var position = completionContext.Position;
var document = completionContext.Document;
var syntaxTree = ctx.SyntaxTree;
if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
return Task.FromResult (Enumerable.Empty<CompletionData> ());
if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken))
return Task.FromResult (Enumerable.Empty<CompletionData> ());
var ma = ctx.LeftToken.Parent as MemberAccessExpressionSyntax;
if (ma == null)
return Task.FromResult (Enumerable.Empty<CompletionData> ());
var model = ctx.CSharpSyntaxContext.SemanticModel;
var symbolInfo = model.GetSymbolInfo (ma.Expression);
if (symbolInfo.Symbol == null || symbolInfo.Symbol.Kind != SymbolKind.Parameter)
return Task.FromResult (Enumerable.Empty<CompletionData> ());
var list = new List<CompletionData> ();
var within = model.GetEnclosingNamedTypeOrAssembly(position, cancellationToken);
var addedSymbols = new HashSet<string> ();
foreach (var ano in ma.AncestorsAndSelf ().OfType<AnonymousMethodExpressionSyntax> ()) {
Analyze (engine, model, ma.Expression, within, list, ano.ParameterList, symbolInfo.Symbol, addedSymbols, cancellationToken);
}
foreach (var ano in ma.AncestorsAndSelf ().OfType<ParenthesizedLambdaExpressionSyntax> ()) {
Analyze (engine, model, ma.Expression, within, list, ano.ParameterList, symbolInfo.Symbol, addedSymbols, cancellationToken);
}
return Task.FromResult ((IEnumerable<CompletionData>)list);
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var model = ctx.SemanticModel;
var tree = ctx.SyntaxTree;
if (tree.IsInNonUserCode (completionContext.Position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
var token = tree.FindTokenOnLeftOfPosition (completionContext.Position, cancellationToken);
if (token.IsMandatoryNamedParameterPosition ())
return Enumerable.Empty<CompletionData> ();
var result = new List<CompletionData> ();
// check if it's the first parameter and set autoselect == false if a parameterless version exists.
if (token.IsKind (SyntaxKind.OpenParenToken)) {
var parent = token.Parent?.Parent;
if (parent == null)
return Enumerable.Empty<CompletionData> ();
var symbolInfo = model.GetSymbolInfo (parent);
foreach (var symbol in new [] { symbolInfo.Symbol }.Concat (symbolInfo.CandidateSymbols)) {
if (symbol != null && symbol.IsKind (SymbolKind.Method)) {
if (symbol.GetParameters ().Length == 0) {
completionResult.AutoSelect = false;
break;
}
}
}
}
foreach (var _type in ctx.InferredTypes) {
var type = _type;
if (type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) {
type = type.GetTypeArguments ().FirstOrDefault ();
if (type == null)
continue;
}
if (type.TypeKind != TypeKind.Enum)
continue;
if (!type.IsEditorBrowsable ())
continue;
// Does type have any aliases?
ISymbol alias = await type.FindApplicableAlias (completionContext.Position, model, cancellationToken).ConfigureAwait (false);
var displayString = RoslynCompletionData.SafeMinimalDisplayString (type, model, completionContext.Position, SymbolDisplayFormat.CSharpErrorMessageFormat);
if (string.IsNullOrEmpty (completionResult.DefaultCompletionString)) {
completionResult.DefaultCompletionString = displayString;
completionResult.AutoCompleteEmptyMatch = true;
}
if (!IsReachable (model, type, token.Parent))
result.Add (engine.Factory.CreateSymbolCompletionData (this, type, displayString));
foreach (IFieldSymbol field in type.GetMembers ().OfType<IFieldSymbol> ()) {
if (field.DeclaredAccessibility == Accessibility.Public && (field.IsConst || field.IsStatic)) {
result.Add (engine.Factory.CreateEnumMemberCompletionData (this, alias, field));
}
}
}
return result;
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var tree = ctx.SyntaxTree;
//DeclarationModifiers modifiers;
SyntaxToken token;
var semanticModel = ctx.SemanticModel;
var enclosingSymbol = semanticModel.GetEnclosingSymbol (position, cancellationToken) as INamedTypeSymbol;
// Only inside classes and structs
if (enclosingSymbol == null || !(enclosingSymbol.TypeKind == TypeKind.Struct || enclosingSymbol.TypeKind == TypeKind.Class)) {
return Enumerable.Empty<CompletionData> ();
}
if (!IsPartialCompletionContext (tree, position, cancellationToken/*, out modifiers*/, out token)) {
if (enclosingSymbol != null && (token.IsKind (SyntaxKind.OpenBraceToken) || token.IsKind (SyntaxKind.CloseBraceToken) || token.IsKind (SyntaxKind.SemicolonToken))) {
return CreateCompletionData (engine, semanticModel, position, enclosingSymbol, token, false, cancellationToken);
}
return Enumerable.Empty<CompletionData> ();
}
return CreateCompletionData (engine, semanticModel, position, enclosingSymbol, token, true, cancellationToken);
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var position = completionContext.Position;
var document = completionContext.Document;
var span = new TextSpan(position, 0);
var semanticModel = await document.GetCSharpSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
var syntaxTree = semanticModel.SyntaxTree;
// var ctx = await completionContext.GetSyntaxContextAsync (engine.Workspace, cancellationToken).ConfigureAwait (false);
if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
{
return Enumerable.Empty<CompletionData> ();
}
if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken))
{
return Enumerable.Empty<CompletionData> ();
}
var node = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken)
.GetPreviousTokenIfTouchingWord(position)
.Parent;
if (node.Kind() == SyntaxKind.ExplicitInterfaceSpecifier)
{
return await GetCompletionsOffOfExplicitInterfaceAsync(
engine, document, semanticModel, position, ((ExplicitInterfaceSpecifierSyntax)node).Name, cancellationToken).ConfigureAwait(false);
}
return Enumerable.Empty<CompletionData> ();
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var semanticModel = ctx.SemanticModel;
if (ctx.TargetToken.Parent != null && ctx.TargetToken.Parent.Parent != null &&
ctx.TargetToken.Parent.Parent.IsKind(SyntaxKind.Argument)) {
SourceText text;
if (!completionContext.Document.TryGetText (out text)) {
text = await completionContext.Document.GetTextAsync ();
}
var currentChar = text [completionContext.Position - 1];
if (ctx.TargetToken.Parent == null || !ctx.TargetToken.Parent.IsKind(SyntaxKind.StringLiteralExpression) ||
ctx.TargetToken.Parent.Parent == null || !ctx.TargetToken.Parent.Parent.IsKind(SyntaxKind.Argument) ||
ctx.TargetToken.Parent.Parent.Parent == null || !ctx.TargetToken.Parent.Parent.Parent.IsKind(SyntaxKind.ArgumentList) ||
ctx.TargetToken.Parent.Parent.Parent.Parent == null || !ctx.TargetToken.Parent.Parent.Parent.Parent.IsKind(SyntaxKind.InvocationExpression)) {
return Enumerable.Empty<CompletionData> ();
}
var formatArgument = GetFormatItemNumber(document, position);
var invocationExpression = ctx.TargetToken.Parent.Parent.Parent.Parent as InvocationExpressionSyntax;
return GetFormatCompletionData(engine, semanticModel, invocationExpression, formatArgument, currentChar);
}
return Enumerable.Empty<CompletionData> ();
}
IEnumerable <CompletionData> GetFormatCompletionData(CompletionEngine engine, bool isVerbatimString)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "d", "Digit character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "D", "Non-digit character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "b", "Word boundary", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "B", "Non-word boundary", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "w", "Word character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "W", "Non-word character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "s", "White-space character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "S", "Non-white-space character", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "A", "Start boundary", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "Z", "End boundary", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "k<name>", "Named backreference", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "P{name}", "Negative unicode category or unicode block", null));
yield return(engine.Factory.CreateFormatItemCompletionData(this, (isVerbatimString ? "" : "\\") + "p{name}", "Unicode category or unicode block", null));
}
IEnumerable<CompletionData> GenerateNumberFormatitems(CompletionEngine engine, bool isFloatingPoint)
{
yield return engine.Factory.CreateFormatItemCompletionData(this, "D", "decimal", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "D5", "decimal", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "C", "currency", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "C0", "currency", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "E", "exponential", 1.23E4);
yield return engine.Factory.CreateFormatItemCompletionData(this, "E2", "exponential", 1.234);
yield return engine.Factory.CreateFormatItemCompletionData(this, "e2", "exponential", 1.234);
yield return engine.Factory.CreateFormatItemCompletionData(this, "F", "fixed-point", 123.45);
yield return engine.Factory.CreateFormatItemCompletionData(this, "F1", "fixed-point", 123.45);
yield return engine.Factory.CreateFormatItemCompletionData(this, "G", "general", 1.23E+56);
yield return engine.Factory.CreateFormatItemCompletionData(this, "g2", "general", 1.23E+56);
yield return engine.Factory.CreateFormatItemCompletionData(this, "N", "number", 12345.68);
yield return engine.Factory.CreateFormatItemCompletionData(this, "N1", "number", 12345.68);
yield return engine.Factory.CreateFormatItemCompletionData(this, "P", "percent", 12.34);
yield return engine.Factory.CreateFormatItemCompletionData(this, "P1", "percent", 12.34);
yield return engine.Factory.CreateFormatItemCompletionData(this, "R", "round-trip", 0.1230000001);
yield return engine.Factory.CreateFormatItemCompletionData(this, "X", "hexadecimal", 1234);
yield return engine.Factory.CreateFormatItemCompletionData(this, "x8", "hexadecimal", 1234);
yield return engine.Factory.CreateFormatItemCompletionData(this, "0000", "custom", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "####", "custom", 123);
yield return engine.Factory.CreateFormatItemCompletionData(this, "##.###", "custom", 1.23);
yield return engine.Factory.CreateFormatItemCompletionData(this, "##.000", "custom", 1.23);
yield return engine.Factory.CreateFormatItemCompletionData(this, "## 'items'", "custom", 12);
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var tree = ctx.SyntaxTree;
if (tree.IsInNonUserCode(position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
var targetToken = tree.FindTokenOnLeftOfPosition(position, cancellationToken).GetPreviousTokenIfTouchingWord(position);
if (targetToken.IsKind(SyntaxKind.AliasKeyword) && targetToken.Parent.IsKind(SyntaxKind.ExternAliasDirective))
{
var compilation = await document.GetCSharpCompilationAsync(cancellationToken).ConfigureAwait(false);
var aliases = compilation.ExternalReferences.Where(r => r.Properties.Aliases != null).SelectMany(r => r.Properties.Aliases).ToSet();
if (aliases.Any())
{
var root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var usedAliases = root.ChildNodes().OfType<ExternAliasDirectiveSyntax>().Where(e => !e.Identifier.IsMissing).Select(e => e.Identifier.ValueText);
foreach (var used in usedAliases) {
aliases.Remove (used);
}
aliases.Remove(MetadataReferenceProperties.GlobalAlias);
return aliases.Select (e => engine.Factory.CreateGenericData (this, e, GenericDataType.Undefined));
}
}
return Enumerable.Empty<CompletionData> ();
}
void Analyze(CompletionEngine engine, SyntaxNode node, ITypeSymbol type, ITypeSymbol stopAt, ISymbol within, List <CompletionData> list, HashSet <string> addedSymbols, CancellationToken cancellationToken)
{
var startType = type;
while (type != null && type.SpecialType != SpecialType.System_Object && type != stopAt)
{
foreach (var member in type.GetMembers())
{
cancellationToken.ThrowIfCancellationRequested();
if (member.IsImplicitlyDeclared || member.IsStatic)
{
continue;
}
if (member.IsOrdinaryMethod() || member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property)
{
if (member.IsAccessibleWithin(within))
{
var completionData = engine.Factory.CreateCastCompletionData(this, member, node, startType);
if (addedSymbols.Contains(completionData.DisplayText))
{
continue;
}
addedSymbols.Add(completionData.DisplayText);
list.Add(completionData);
}
}
}
type = type.BaseType;
}
}
protected override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult result, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var tree = ctx.SyntaxTree;
var model = ctx.SemanticModel;
if (tree.IsInNonUserCode (position, cancellationToken))
return Task.FromResult (Enumerable.Empty<CompletionData> ());
if (!ctx.CSharpSyntaxContext.IsAnyExpressionContext)
return Task.FromResult (Enumerable.Empty<CompletionData> ());
var enclosingType = model.GetEnclosingNamedType (position, cancellationToken);
var memberMethods = enclosingType.GetMembers ().OfType<IMethodSymbol> ().Where (m => m.MethodKind == MethodKind.Ordinary).ToArray ();
var list = new List<CompletionData> ();
foreach (var type in ctx.InferredTypes) {
if (type.TypeKind != TypeKind.Delegate)
continue;
AddCompatibleMethods (engine, list, type, memberMethods, cancellationToken);
string delegateName = null;
if (ctx.TargetToken.IsKind (SyntaxKind.PlusEqualsToken)) {
delegateName = GuessEventHandlerBaseName (ctx.LeftToken.Parent, ctx.ContainingTypeDeclaration);
}
AddDelegateHandlers (list, ctx.TargetToken.Parent, model, engine, result, type, position, delegateName, cancellationToken);
}
if (list.Count > 0) {
result.AutoSelect = false;
}
return Task.FromResult ((IEnumerable<CompletionData>)list);
}
IEnumerable <CompletionData> GenerateTimeSpanFormatitems(CompletionEngine engine)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, "c", "invariant", new TimeSpan(0, 1, 23, 456)));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "G", "general long", new TimeSpan(0, 1, 23, 456)));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "g", "general short", new TimeSpan(0, 1, 23, 456)));
}
Task <IEnumerable <CompletionData> > GetSnippetCompletionItemsAsync(CancellationToken cancellationToken)
{
if (CompletionEngine.SnippetCallback == null)
{
return(Task.FromResult(Enumerable.Empty <CompletionData>()));
}
return(CompletionEngine.SnippetCallback(cancellationToken));
}
//
// public override bool SendEnterThroughToEditor(ICompletionData ICompletionData, string textTypedSoFar)
// {
// return false;
// }
private IEnumerable <CompletionData> GetTopLevelSingleUseNames(CompletionEngine engine, DocumentationCommentTriviaSyntax parentTrivia, TextSpan span)
{
var names = new HashSet <string>(new[] { "summary", "remarks", "example", "completionlist" });
RemoveExistingTags(parentTrivia, names, (x) => x.StartTag.Name.LocalName.ValueText);
return(names.Select(n => GetItem(engine, n, span)));
}
protected CompletionData GetItem(CompletionEngine engine, string n, TextSpan span)
{
if (_tagMap.ContainsKey(n))
{
var value = _tagMap[n];
return(engine.Factory.CreateXmlDocCompletionData(this, n, null, value [0] + "|" + value [1]));
}
return(engine.Factory.CreateXmlDocCompletionData(this, n));
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
return await document.GetUnionResultsFromDocumentAndLinks(
UnionCompletionItemComparer.Instance,
async (doc, ct) => await GetSpeculativeTCompletions(engine, doc, position, ct).ConfigureAwait(false),
cancellationToken).ConfigureAwait(false);
}
IEnumerable <CompletionData> GenerateEnumFormatitems(CompletionEngine engine)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, "G", "string value", TestEnum.EnumCaseName));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "F", "flags value", TestEnum.Flags));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "D", "integer value", TestEnum.Flags));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "X", "hexadecimal", TestEnum.Flags));
}
IEnumerable <CompletionData> GenerateGuidFormatitems(CompletionEngine engine)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, "N", "digits", defaultGuid));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "D", "hypens", defaultGuid));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "B", "braces", defaultGuid));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "P", "parentheses", defaultGuid));
}
protected IEnumerable <CompletionData> GetAttributeItem(CompletionEngine engine, string n, TextSpan span)
{
var items = _attributeMap.Where(x => x[0] == n).Select(x => engine.Factory.CreateXmlDocCompletionData(this, x[1], null, x[2] + "|" + x[3]));
if (items.Any())
{
return(items);
}
return(new [] { engine.Factory.CreateXmlDocCompletionData(this, n) });
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var syntaxTree = await document.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken) ||
syntaxTree.GetContainingTypeOrEnumDeclaration(position, cancellationToken) is EnumDeclarationSyntax)
{
return Enumerable.Empty<CompletionData>();
}
// var span = new TextSpan(position, 0);
// var semanticModel = await document.GetCSharpSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
{
var directive = syntaxTree.GetRoot(cancellationToken).FindTokenOnLeftOfPosition(position, includeDirectives: true).GetAncestor<DirectiveTriviaSyntax>();
if (directive.DirectiveNameToken.IsKind(
SyntaxKind.IfKeyword,
SyntaxKind.RegionKeyword,
SyntaxKind.ElseKeyword,
SyntaxKind.ElifKeyword,
SyntaxKind.ErrorKeyword,
SyntaxKind.LineKeyword,
SyntaxKind.PragmaKeyword,
SyntaxKind.EndIfKeyword,
SyntaxKind.UndefKeyword,
SyntaxKind.EndRegionKeyword,
SyntaxKind.WarningKeyword))
{
return Enumerable.Empty<CompletionData>();
}
return await GetSnippetCompletionItemsAsync(cancellationToken).ConfigureAwait(false);
}
var tokenLeftOfPosition = syntaxTree.FindTokenOnLeftOfPosition (position, cancellationToken);
if (syntaxTree.IsGlobalStatementContext(position, cancellationToken) ||
syntaxTree.IsExpressionContext(position, tokenLeftOfPosition, true, cancellationToken) ||
syntaxTree.IsStatementContext(position, tokenLeftOfPosition, cancellationToken) ||
syntaxTree.IsTypeContext(position, cancellationToken) ||
syntaxTree.IsTypeDeclarationContext(position, tokenLeftOfPosition, cancellationToken) ||
syntaxTree.IsNamespaceContext(position, cancellationToken) ||
syntaxTree.IsMemberDeclarationContext(position, tokenLeftOfPosition, cancellationToken) ||
syntaxTree.IsLabelContext(position, cancellationToken))
{
return await GetSnippetCompletionItemsAsync(cancellationToken).ConfigureAwait(false);
}
return Enumerable.Empty<CompletionData>();
}
private IEnumerable <CompletionData> GetTagsForProperty(CompletionEngine engine, IPropertySymbol symbol, TextSpan filterSpan, DocumentationCommentTriviaSyntax trivia)
{
var items = new List <CompletionData>();
var typeParameters = symbol.GetTypeArguments().Select(p => p.Name).ToSet();
RemoveExistingTags(trivia, typeParameters, x => AttributeSelector(x, "typeparam"));
items.AddRange(typeParameters.Select(t => engine.Factory.CreateXmlDocCompletionData(this, "typeparam", null, "name$" + t)));
items.Add(engine.Factory.CreateXmlDocCompletionData(this, "value"));
return(items);
}
IEnumerable <CompletionData> GetFormatCompletionForType(CompletionEngine engine, ITypeSymbol type)
{
if (type == null)
{
return(GenerateNumberFormatitems(engine, false)
.Concat(GenerateDateTimeFormatitems(engine))
.Concat(GenerateTimeSpanFormatitems(engine))
.Concat(GenerateEnumFormatitems(engine))
.Concat(GenerateGuidFormatitems(engine)));
}
switch (type.ToString())
{
case "long":
case "System.Int64":
case "ulong":
case "System.UInt64":
case "int":
case "System.Int32":
case "uint":
case "System.UInt32":
case "short":
case "System.Int16":
case "ushort":
case "System.UInt16":
case "byte":
case "System.Byte":
case "sbyte":
case "System.SByte":
return(GenerateNumberFormatitems(engine, false));
case "float":
case "System.Single":
case "double":
case "System.Double":
case "decimal":
case "System.Decimal":
return(GenerateNumberFormatitems(engine, true));
case "System.Enum":
return(GenerateEnumFormatitems(engine));
case "System.DateTime":
return(GenerateDateTimeFormatitems(engine));
case "System.TimeSpan":
return(GenerateTimeSpanFormatitems(engine));
case "System.Guid":
return(GenerateGuidFormatitems(engine));
}
return(CompletionResult.Empty.Data);
}
void AddCompatibleMethods(CompletionEngine engine, List <CompletionData> list, ITypeSymbol delegateType, IMethodSymbol [] memberMethods, CancellationToken cancellationToken)
{
var delegateMethod = delegateType.GetDelegateInvokeMethod();
foreach (var method in memberMethods)
{
if (method.ReturnType.Equals(delegateMethod.ReturnType) && SignatureComparer.HaveSameSignature(delegateMethod.Parameters, method.Parameters, false, false))
{
list.Add(engine.Factory.CreateExistingMethodDelegate(this, method));
}
}
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var model = ctx.SemanticModel;
var result = new List<CompletionData> ();
if (ctx.IsPreProcessorExpressionContext) {
var parseOptions = model.SyntaxTree.Options as CSharpParseOptions;
foreach (var define in parseOptions.PreprocessorSymbolNames) {
result.Add(engine.Factory.CreateGenericData (this, define, GenericDataType.PreprocessorSymbol));
}
}
return result;
}
private IEnumerable <CompletionData> GetTagsForType(CompletionEngine engine, INamedTypeSymbol symbol, TextSpan filterSpan, DocumentationCommentTriviaSyntax trivia)
{
var items = new List <CompletionData>();
var typeParameters = symbol.TypeParameters.Select(p => p.Name).ToSet();
RemoveExistingTags(trivia, typeParameters, x => AttributeSelector(x, "typeparam"));
items.AddRange(typeParameters.Select(t => engine.Factory.CreateXmlDocCompletionData(
this,
FormatParameter("typeparam", t))));
return(items);
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
// var ctx = await completionContext.GetSyntaxContextAsync (engine.Workspace, cancellationToken).ConfigureAwait (false);
var document = completionContext.Document;
var semanticModel = ctx.SemanticModel;
var tree = ctx.SyntaxTree;
if (tree.IsInNonUserCode(completionContext.Position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
var text = await document.GetTextAsync (cancellationToken).ConfigureAwait (false);
var startLineNumber = text.Lines.IndexOf (completionContext.Position);
// modifiers* override modifiers* type? |
Accessibility seenAccessibility;
//DeclarationModifiers modifiers;
var token = tree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken);
if (token.Parent == null)
return Enumerable.Empty<CompletionData> ();
var parentMember = token.Parent.AncestorsAndSelf ().OfType<MemberDeclarationSyntax> ().FirstOrDefault (m => !m.IsKind (SyntaxKind.IncompleteMember));
if (!(parentMember is BaseTypeDeclarationSyntax) &&
/* May happen in case:
*
* override $
* public override string Foo () {}
*/
!(token.IsKind (SyntaxKind.OverrideKeyword) && token.Span.Start <= parentMember.Span.Start))
return Enumerable.Empty<CompletionData> ();
var position = completionContext.Position;
var startToken = token.GetPreviousTokenIfTouchingWord(position);
ITypeSymbol returnType;
SyntaxToken tokenBeforeReturnType;
TryDetermineReturnType (startToken, semanticModel, cancellationToken, out returnType, out tokenBeforeReturnType);
if (returnType == null) {
var enclosingType = semanticModel.GetEnclosingSymbol (position, cancellationToken) as INamedTypeSymbol;
if (enclosingType != null && (startToken.IsKind (SyntaxKind.OpenBraceToken) || startToken.IsKind (SyntaxKind.CloseBraceToken) || startToken.IsKind (SyntaxKind.SemicolonToken))) {
return CreateCompletionData (engine, semanticModel, position, returnType, Accessibility.NotApplicable, startToken, tokenBeforeReturnType, false, cancellationToken);
}
}
if (!TryDetermineModifiers(ref tokenBeforeReturnType, text, startLineNumber, out seenAccessibility/*, out modifiers*/) ||
!TryCheckForTrailingTokens (tree, text, startLineNumber, position, cancellationToken)) {
return Enumerable.Empty<CompletionData> ();
}
return CreateCompletionData (engine, semanticModel, position, returnType, seenAccessibility, startToken, tokenBeforeReturnType, true, cancellationToken);
}
private async Task<IEnumerable<CompletionData>> GetSpeculativeTCompletions(CompletionEngine engine, Document document, int position, CancellationToken cancellationToken)
{
var syntaxTree = await document.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
{
return Enumerable.Empty<CompletionData>();
}
// If we're in a generic type argument context, use the start of the generic type name
// as the position for the rest of the context checks.
int testPosition = position;
var leftToken = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken);
var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(leftToken.Parent, cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsGenericTypeArgumentContext(position, leftToken, cancellationToken, semanticModel))
{
// Walk out until we find the start of the partial written generic
SyntaxToken nameToken;
while (syntaxTree.IsInPartiallyWrittenGeneric(testPosition, cancellationToken, out nameToken))
{
testPosition = nameToken.SpanStart;
}
// If the user types Foo<T, automatic brace completion will insert the close brace
// and the generic won't be "partially written".
if (testPosition == position)
{
var typeArgumentList = leftToken.GetAncestor<TypeArgumentListSyntax>();
if (typeArgumentList != null)
{
if (typeArgumentList.LessThanToken != default(SyntaxToken) && typeArgumentList.GreaterThanToken != default(SyntaxToken))
{
testPosition = typeArgumentList.LessThanToken.SpanStart;
}
}
}
}
if ((!leftToken.GetPreviousTokenIfTouchingWord(position).IsKindOrHasMatchingText(SyntaxKind.AsyncKeyword) &&
syntaxTree.IsMemberDeclarationContext(testPosition, contextOpt: null, validModifiers: SyntaxKindSet.AllMemberModifiers, validTypeDeclarations: SyntaxKindSet.ClassInterfaceStructTypeDeclarations, canBePartial: false, cancellationToken: cancellationToken)) ||
syntaxTree.IsGlobalMemberDeclarationContext(testPosition, SyntaxKindSet.AllGlobalMemberModifiers, cancellationToken) ||
syntaxTree.IsGlobalStatementContext(testPosition, cancellationToken) ||
syntaxTree.IsDelegateReturnTypeContext(testPosition, syntaxTree.FindTokenOnLeftOfPosition(testPosition, cancellationToken), cancellationToken))
{
const string T = "T";
return new [] { engine.Factory.CreateGenericData (this, T, GenericDataType.Undefined) };
}
return Enumerable.Empty<CompletionData>();
}
private Task <IEnumerable <CompletionData> > GetNameColonItemsAsync(
CompletionEngine engine, Workspace workspace, SemanticModel semanticModel, int position, SyntaxToken token, AttributeSyntax attributeSyntax, ISet <string> existingNamedParameters,
CancellationToken cancellationToken)
{
var parameterLists = GetParameterLists(semanticModel, position, attributeSyntax, cancellationToken);
parameterLists = parameterLists.Where(pl => IsValid(pl, existingNamedParameters));
// var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
return(Task.FromResult(
from pl in parameterLists
from p in pl
where !existingNamedParameters.Contains(p.Name)
select engine.Factory.CreateGenericData(this, p.Name + ":", GenericDataType.NamedParameter)));
}
IEnumerable <CompletionData> GenerateDateTimeFormatitems(CompletionEngine engine)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, "D", "long date", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "d", "short date", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "F", "full date long", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "f", "full date short", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "G", "general long", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "g", "general short", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "M", "month", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "O", "ISO 8601", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "R", "RFC 1123", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "s", "sortable", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "T", "long time", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "t", "short time", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "U", "universal full", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "u", "universal sortable", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "Y", "year month", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "yy-MM-dd", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "yyyy MMMMM dd", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "yy-MMM-dd ddd", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "yyyy-M-d dddd", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "hh:mm:ss t z", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "hh:mm:ss tt zz", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "HH:mm:ss tt zz", "custom", curDate));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "HH:m:s tt zz", "custom", curDate));
}
IEnumerable <CompletionData> GenerateNumberFormatitems(CompletionEngine engine, bool isFloatingPoint)
{
yield return(engine.Factory.CreateFormatItemCompletionData(this, "D", "decimal", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "D5", "decimal", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "C", "currency", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "C0", "currency", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "E", "exponential", 1.23E4));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "E2", "exponential", 1.234));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "e2", "exponential", 1.234));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "F", "fixed-point", 123.45));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "F1", "fixed-point", 123.45));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "G", "general", 1.23E+56));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "g2", "general", 1.23E+56));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "N", "number", 12345.68));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "N1", "number", 12345.68));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "P", "percent", 12.34));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "P1", "percent", 12.34));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "R", "round-trip", 0.1230000001));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "X", "hexadecimal", 1234));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "x8", "hexadecimal", 1234));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "0000", "custom", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "####", "custom", 123));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "##.###", "custom", 1.23));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "##.000", "custom", 1.23));
yield return(engine.Factory.CreateFormatItemCompletionData(this, "## 'items'", "custom", 12));
}
IEnumerable <CompletionData> GetFormatCompletionData(CompletionEngine engine, SemanticModel semanticModel, InvocationExpressionSyntax invocationExpression, int formatArgument, char currentChar)
{
var symbolInfo = semanticModel.GetSymbolInfo(invocationExpression);
var method = symbolInfo.Symbol as IMethodSymbol ?? symbolInfo.CandidateSymbols.OfType <IMethodSymbol> ().FirstOrDefault();
var ma = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (ma != null && ma.Name.ToString() == "ToString")
{
if (method == null || currentChar != '"')
{
return(Enumerable.Empty <CompletionData> ());
}
if (method != null)
{
return(GetFormatCompletionForType(engine, method.ContainingType));
}
else
{
return(Enumerable.Empty <CompletionData> ());
}
}
else
{
if (method == null || currentChar != ':')
{
return(Enumerable.Empty <CompletionData> ());
}
ExpressionSyntax fmtArgumets;
IList <ExpressionSyntax> args;
if (FormatStringHelper.TryGetFormattingParameters(semanticModel, invocationExpression, out fmtArgumets, out args, null))
{
ITypeSymbol type = null;
if (formatArgument + 1 < args.Count)
{
var invokeArgument = semanticModel.GetSymbolInfo(args[formatArgument + 1]);
if (invokeArgument.Symbol != null)
{
type = invokeArgument.Symbol.GetReturnType();
}
}
return(GetFormatCompletionForType(engine, type));
}
}
return(Enumerable.Empty <CompletionData> ());
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var syntaxTree = ctx.SyntaxTree;
if (syntaxTree.IsInNonUserCode(position, cancellationToken))
{
return null;
}
var token = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken);
token = token.GetPreviousTokenIfTouchingWord(position);
if (token.Kind() != SyntaxKind.OpenParenToken && token.Kind() != SyntaxKind.CommaToken)
{
return null;
}
var attributeArgumentList = token.Parent as AttributeArgumentListSyntax;
var attributeSyntax = token.Parent.Parent as AttributeSyntax;
if (attributeSyntax == null || attributeArgumentList == null)
{
return null;
}
// We actually want to collect two sets of named parameters to present the user. The
// normal named parameters that come from the attribute constructors. These will be
// presented like "foo:". And also the named parameters that come from the writable
// fields/properties in the attribute. These will be presented like "bar =".
var existingNamedParameters = GetExistingNamedParameters(attributeArgumentList, position);
var workspace = document.Project.Solution.Workspace;
var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(attributeSyntax, cancellationToken).ConfigureAwait(false);
var nameColonItems = await GetNameColonItemsAsync(engine, workspace, semanticModel, position, token, attributeSyntax, existingNamedParameters, cancellationToken).ConfigureAwait(false);
var nameEqualsItems = await GetNameEqualsItemsAsync(engine, workspace, semanticModel, position, token, attributeSyntax, existingNamedParameters, cancellationToken).ConfigureAwait(false);
// If we're after a name= parameter, then we only want to show name= parameters.
if (IsAfterNameEqualsArgument(token))
{
return nameEqualsItems;
}
return nameColonItems.Concat(nameEqualsItems);
}
protected override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var document = completionContext.Document;
var position = completionContext.Position;
var semanticModel = ctx.SemanticModel;
if (info.TriggerCharacter == '\\') {
if (ctx.TargetToken.Parent != null && ctx.TargetToken.Parent.Parent != null &&
ctx.TargetToken.Parent.Parent.IsKind (SyntaxKind.Argument)) {
var argument = ctx.TargetToken.Parent.Parent as ArgumentSyntax;
var symbolInfo = semanticModel.GetSymbolInfo (ctx.TargetToken.Parent.Parent.Parent.Parent);
if (symbolInfo.Symbol == null)
return TaskUtil.EmptyEnumerable<CompletionData> ();
if (SemanticHighlightingVisitor<int>.IsRegexMatchMethod (symbolInfo)) {
if (((ArgumentListSyntax)argument.Parent).Arguments [1] != argument)
return TaskUtil.EmptyEnumerable<CompletionData> ();
completionResult.AutoSelect = false;
return Task.FromResult (GetFormatCompletionData (engine, argument.Expression.ToString () [0] == '@'));
}
if (SemanticHighlightingVisitor<int>.IsRegexConstructor (symbolInfo)) {
if (((ArgumentListSyntax)argument.Parent).Arguments [0] != argument)
return TaskUtil.EmptyEnumerable<CompletionData> ();
completionResult.AutoSelect = false;
return Task.FromResult (GetFormatCompletionData (engine, argument.Expression.ToString () [0] == '@'));
}
}
} else {
var ma = ctx.TargetToken.Parent as MemberAccessExpressionSyntax;
if (ma != null) {
var symbolInfo = semanticModel.GetSymbolInfo (ma.Expression);
var typeInfo = semanticModel.GetTypeInfo (ma.Expression);
var type = typeInfo.Type;
if (type != null && type.Name == "Match" && type.ContainingNamespace.GetFullName () == "System.Text.RegularExpressions" ) {
var items = new List<CompletionData>();
foreach (var grp in GetGroups (ctx, symbolInfo.Symbol)) {
items.Add (engine.Factory.CreateGenericData (this, "Groups[\"" + grp + "\"]", GenericDataType.Undefined));
}
return Task.FromResult ((IEnumerable<CompletionData>)items);
}
}
}
return TaskUtil.EmptyEnumerable<CompletionData> ();
}
protected override IEnumerable<CompletionData> CreateCompletionData (CompletionEngine engine, SemanticModel semanticModel, int position, ITypeSymbol returnType, Accessibility seenAccessibility, SyntaxToken startToken, SyntaxToken tokenBeforeReturnType, bool afterKeyword, CancellationToken cancellationToken)
{
var result = new List<CompletionData> ();
ISet<ISymbol> overridableMembers;
if (!TryDetermineOverridableMembers (semanticModel, tokenBeforeReturnType, seenAccessibility, out overridableMembers, cancellationToken)) {
return result;
}
if (returnType != null) {
overridableMembers = FilterOverrides (overridableMembers, returnType);
}
var curType = semanticModel.GetEnclosingSymbol<INamedTypeSymbol> (startToken.SpanStart, cancellationToken);
var declarationBegin = afterKeyword ? startToken.SpanStart : position - 1;
foreach (var m in overridableMembers) {
var data = new ProtocolCompletionData (this, factory, declarationBegin, curType, m, afterKeyword);
result.Add (data);
}
return result;
}
private Task <IEnumerable <CompletionData> > GetNameEqualsItemsAsync(CompletionEngine engine, Workspace workspace, SemanticModel semanticModel,
int position, SyntaxToken token, AttributeSyntax attributeSyntax, ISet <string> existingNamedParameters,
CancellationToken cancellationToken)
{
var attributeNamedParameters = GetAttributeNamedParameters(semanticModel, position, attributeSyntax, cancellationToken);
// var unspecifiedNamedParameters = attributeNamedParameters.Where(p => !existingNamedParameters.Contains(p.Name));
// var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
return(Task.FromResult(
attributeNamedParameters
.Where(p => !existingNamedParameters.Contains(p.Name))
.Select(p => {
var result = engine.Factory.CreateSymbolCompletionData(this, p);
result.DisplayFlags |= DisplayFlags.NamedArgument;
return (CompletionData)result;
})));
}
private IEnumerable <CompletionData> GetTagsForSymbol(CompletionEngine engine, ISymbol symbol, TextSpan filterSpan, DocumentationCommentTriviaSyntax trivia, SyntaxToken token)
{
if (symbol is IMethodSymbol)
{
return(GetTagsForMethod(engine, (IMethodSymbol)symbol, filterSpan, trivia, token));
}
if (symbol is IPropertySymbol)
{
return(GetTagsForProperty(engine, (IPropertySymbol)symbol, filterSpan, trivia));
}
if (symbol is INamedTypeSymbol)
{
return(GetTagsForType(engine, (INamedTypeSymbol)symbol, filterSpan, trivia));
}
return(SpecializedCollections.EmptyEnumerable <CompletionData>());
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult result, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var list = new List<CompletionData> ();
var newExpression = GetObjectCreationNewExpression (ctx.SyntaxTree, completionContext.Position, cancellationToken);
if (newExpression == null) {
if (ctx.SyntaxTree.IsInNonUserCode(completionContext.Position, cancellationToken) ||
ctx.SyntaxTree.IsPreProcessorDirectiveContext(completionContext.Position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
// if (!nkr.IsValid (completionContext.Position, ctx.CSharpSyntaxContext, cancellationToken))
// return Enumerable.Empty<ICompletionData> ();
var tokenOnLeftOfPosition = ctx.SyntaxTree.FindTokenOnLeftOfPosition (completionContext.Position, cancellationToken);
if (!tokenOnLeftOfPosition.IsKind (SyntaxKind.EqualsToken) && !tokenOnLeftOfPosition.Parent.IsKind (SyntaxKind.EqualsValueClause))
return Enumerable.Empty<CompletionData> ();
foreach (var inferredType in SyntaxContext.InferenceService.InferTypes (ctx.CSharpSyntaxContext.SemanticModel, completionContext.Position, cancellationToken)) {
if (inferredType.IsEnumType () || inferredType.IsInterfaceType () || inferredType.IsAbstract)
continue;
foreach (var symbol in await GetPreselectedSymbolsWorker(ctx.CSharpSyntaxContext, inferredType, completionContext.Position - 1, cancellationToken)) {
var symbolCompletionData = engine.Factory.CreateObjectCreation (this, inferredType, symbol, completionContext.Position, false);
list.Add (symbolCompletionData);
}
}
return list;
}
var type = SyntaxContext.InferenceService.InferType (ctx.CSharpSyntaxContext.SemanticModel, newExpression, objectAsDefault: false, cancellationToken: cancellationToken);
foreach (var symbol in await GetPreselectedSymbolsWorker(ctx.CSharpSyntaxContext, type, completionContext.Position, cancellationToken)) {
var symbolCompletionData = engine.Factory.CreateObjectCreation (this, type, symbol, newExpression.SpanStart, true);
list.Add (symbolCompletionData);
if (string.IsNullOrEmpty (result.DefaultCompletionString))
result.DefaultCompletionString = symbolCompletionData.DisplayText;
}
foreach (var keyword in primitiveTypesKeywords) {
list.Add (engine.Factory.CreateGenericData (this, keyword, GenericDataType.Keyword));
}
return list;
}
protected virtual IEnumerable<CompletionData> CreateCompletionData (CompletionEngine engine, SemanticModel semanticModel, int position, INamedTypeSymbol enclosingType, SyntaxToken token, bool afterPartialKeyword, CancellationToken cancellationToken)
{
var symbols = semanticModel.LookupSymbols(position, container: enclosingType)
.OfType<IMethodSymbol>()
.Where(m => IsPartial(m) && m.PartialImplementationPart == null);
var list = new List<CompletionData> ();
var declarationBegin = afterPartialKeyword ? token.Parent.SpanStart : position - 1;
foreach (var m in symbols) {
var data = engine.Factory.CreatePartialCompletionData (
this,
declarationBegin,
enclosingType,
m,
afterPartialKeyword
);
list.Add (data);
}
return list;
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var position = completionContext.Position;
var document = completionContext.Document;
var syntaxTree = ctx.SyntaxTree;
if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
var ma = ctx.LeftToken.Parent as MemberAccessExpressionSyntax;
if (ma == null)
return Enumerable.Empty<CompletionData> ();
var model = ctx.CSharpSyntaxContext.SemanticModel;
var symbolInfo = model.GetSymbolInfo (ma.Expression);
if (symbolInfo.Symbol == null)
return Enumerable.Empty<CompletionData> ();
var list = new List<CompletionData> ();
var within = model.GetEnclosingNamedTypeOrAssembly(position, cancellationToken);
var addedSymbols = new HashSet<string> ();
foreach (var ifStmSyntax in ma.Expression.AncestorsAndSelf ().OfType<IfStatementSyntax> ()) {
var condition = ifStmSyntax.Condition.SkipParens ();
if (condition == null || !condition.IsKind (SyntaxKind.IsExpression))
continue;
var isExpr = ((BinaryExpressionSyntax)condition);
var leftSymbol = model.GetSymbolInfo (isExpr.Left);
if (leftSymbol.Symbol == symbolInfo.Symbol) {
var type = model.GetTypeInfo (isExpr.Right).Type;
if (type != null) {
Analyze (engine, ma.Expression, type, within, list, addedSymbols, cancellationToken);
}
}
}
return list;
}
protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var model = ctx.SemanticModel;
var tree = ctx.SyntaxTree;
if (tree.IsInNonUserCode(completionContext.Position, cancellationToken))
return Enumerable.Empty<CompletionData> ();
var token = tree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken);
if (token.IsMandatoryNamedParameterPosition())
return Enumerable.Empty<CompletionData> ();
var result = new List<CompletionData> ();
foreach (var _type in ctx.InferredTypes) {
var type = _type;
if (type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) {
type = type.GetTypeArguments().FirstOrDefault();
if (type == null)
continue;
}
if (type.TypeKind != TypeKind.Enum)
continue;
if (!type.IsEditorBrowsable ())
continue;
// Does type have any aliases?
ISymbol alias = await type.FindApplicableAlias(completionContext.Position, model, cancellationToken).ConfigureAwait(false);
if (string.IsNullOrEmpty(completionResult.DefaultCompletionString))
completionResult.DefaultCompletionString = type.Name;
result.Add (engine.Factory.CreateSymbolCompletionData(this, type, RoslynCompletionData.SafeMinimalDisplayString (type, model, completionContext.Position, SymbolDisplayFormat.CSharpErrorMessageFormat)));
foreach (IFieldSymbol field in type.GetMembers().OfType<IFieldSymbol>()) {
if (field.DeclaredAccessibility == Accessibility.Public && (field.IsConst || field.IsStatic)) {
result.Add (engine.Factory.CreateEnumMemberCompletionData(this, alias, field));
}
}
}
return result;
}
protected virtual IEnumerable <CompletionData> CreateCompletionData(CompletionEngine engine, SemanticModel semanticModel, int position, ITypeSymbol returnType, Accessibility seenAccessibility, SyntaxToken startToken, SyntaxToken tokenBeforeReturnType, bool afterKeyword, CancellationToken cancellationToken)
{
var result = new List <CompletionData> ();
ISet <ISymbol> overridableMembers;
if (!TryDetermineOverridableMembers(semanticModel, tokenBeforeReturnType, seenAccessibility, out overridableMembers, cancellationToken))
{
return(result);
}
if (returnType != null)
{
overridableMembers = FilterOverrides(overridableMembers, returnType);
}
var curType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol> (position, cancellationToken);
var declarationBegin = afterKeyword ? startToken.Parent.SpanStart : position - 1;
foreach (var m in overridableMembers)
{
var data = engine.Factory.CreateNewOverrideCompletionData(this, declarationBegin, curType, m, afterKeyword);
result.Add(data);
}
return(result);
}
protected virtual IEnumerable <CompletionData> CreateCompletionData(CompletionEngine engine, SemanticModel semanticModel, int position, INamedTypeSymbol enclosingType, SyntaxToken token, bool afterPartialKeyword, CancellationToken cancellationToken)
{
var symbols = semanticModel.LookupSymbols(position, container: enclosingType)
.OfType <IMethodSymbol>()
.Where(m => IsPartial(m) && m.PartialImplementationPart == null);
var list = new List <CompletionData> ();
var declarationBegin = afterPartialKeyword ? token.Parent.SpanStart : position - 1;
foreach (var m in symbols)
{
var data = engine.Factory.CreatePartialCompletionData(
this,
declarationBegin,
enclosingType,
m,
afterPartialKeyword
);
list.Add(data);
}
return(list);
}
void Analyze(CompletionEngine engine, SemanticModel model, SyntaxNode node, ISymbol within, List <CompletionData> list, ParameterListSyntax parameterList, ISymbol symbol, HashSet <string> addedSymbols, CancellationToken cancellationToken)
{
var type = CheckParameterList(model, parameterList, symbol, cancellationToken);
if (type == null)
{
return;
}
var startType = type;
while (type.SpecialType != SpecialType.System_Object)
{
foreach (var member in type.GetMembers())
{
if (member.IsImplicitlyDeclared || member.IsStatic)
{
continue;
}
if (member.IsOrdinaryMethod() || member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property)
{
if (member.IsAccessibleWithin(within))
{
var completionData = engine.Factory.CreateCastCompletionData(this, member, node, startType);
if (addedSymbols.Contains(completionData.DisplayText))
{
continue;
}
addedSymbols.Add(completionData.DisplayText);
list.Add(completionData);
}
}
}
type = type.BaseType;
}
}
IEnumerable<CompletionData> GenerateEnumFormatitems(CompletionEngine engine)
{
yield return engine.Factory.CreateFormatItemCompletionData(this, "G", "string value", TestEnum.EnumCaseName);
yield return engine.Factory.CreateFormatItemCompletionData(this, "F", "flags value", TestEnum.Flags);
yield return engine.Factory.CreateFormatItemCompletionData(this, "D", "integer value", TestEnum.Flags);
yield return engine.Factory.CreateFormatItemCompletionData(this, "X", "hexadecimal", TestEnum.Flags);
}
IEnumerable<CompletionData> GenerateDateTimeFormatitems(CompletionEngine engine)
{
yield return engine.Factory.CreateFormatItemCompletionData(this, "D", "long date", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "d", "short date", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "F", "full date long", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "f", "full date short", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "G", "general long", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "g", "general short", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "M", "month", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "O", "ISO 8601", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "R", "RFC 1123", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "s", "sortable", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "T", "long time", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "t", "short time", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "U", "universal full", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "u", "universal sortable", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "Y", "year month", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "yy-MM-dd", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "yyyy MMMMM dd", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "yy-MMM-dd ddd", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "yyyy-M-d dddd", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "hh:mm:ss t z", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "hh:mm:ss tt zz", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "HH:mm:ss tt zz", "custom", curDate);
yield return engine.Factory.CreateFormatItemCompletionData(this, "HH:m:s tt zz", "custom", curDate);
}
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
if (info.IsDebugger)
{
return(null);
}
if (info.CompletionTriggerReason == CompletionTriggerReason.BackspaceOrDeleteCommand)
{
return(null);
}
var document = completionContext.Document;
var position = completionContext.Position;
var tree = await document.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
var token = tree.FindTokenOnLeftOfPosition(position, cancellationToken);
var parentTrivia = token.GetAncestor <DocumentationCommentTriviaSyntax>();
if (parentTrivia == null)
{
return(null);
}
var items = new List <CompletionData>();
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var span = GetTextChangeSpan(text, position);
var attachedToken = parentTrivia.ParentTrivia.Token;
if (attachedToken.Kind() == SyntaxKind.None)
{
return(null);
}
var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(attachedToken.Parent, cancellationToken).ConfigureAwait(false);
ISymbol declaredSymbol = null;
var memberDeclaration = attachedToken.GetAncestor <MemberDeclarationSyntax>();
if (memberDeclaration != null)
{
declaredSymbol = semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken);
}
else
{
var typeDeclaration = attachedToken.GetAncestor <TypeDeclarationSyntax>();
if (typeDeclaration != null)
{
declaredSymbol = semanticModel.GetDeclaredSymbol(typeDeclaration, cancellationToken);
}
}
if (declaredSymbol != null)
{
items.AddRange(GetTagsForSymbol(engine, declaredSymbol, span, parentTrivia, token));
}
if (token.Parent.Kind() == SyntaxKind.XmlEmptyElement || token.Parent.Kind() == SyntaxKind.XmlText ||
(token.Parent.IsKind(SyntaxKind.XmlElementEndTag) && token.IsKind(SyntaxKind.GreaterThanToken)) ||
(token.Parent.IsKind(SyntaxKind.XmlName) && token.Parent.IsParentKind(SyntaxKind.XmlEmptyElement)))
{
if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement)
{
items.AddRange(GetNestedTags(engine, span));
}
if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement && ((XmlElementSyntax)token.Parent.Parent).StartTag.Name.LocalName.ValueText == "list")
{
items.AddRange(GetListItems(engine, span));
}
if (token.Parent.IsParentKind(SyntaxKind.XmlEmptyElement) & token.Parent.Parent.IsParentKind(SyntaxKind.XmlElement))
{
var element = (XmlElementSyntax)token.Parent.Parent.Parent;
if (element.StartTag.Name.LocalName.ValueText == "list")
{
items.AddRange(GetListItems(engine, span));
}
}
if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement && ((XmlElementSyntax)token.Parent.Parent).StartTag.Name.LocalName.ValueText == "listheader")
{
items.AddRange(GetListHeaderItems(engine, span));
}
if (token.Parent.Parent is DocumentationCommentTriviaSyntax)
{
items.AddRange(GetTopLevelSingleUseNames(engine, parentTrivia, span));
items.AddRange(GetTopLevelRepeatableItems(engine, span));
}
}
if (token.Parent.Kind() == SyntaxKind.XmlElementStartTag)
{
var startTag = (XmlElementStartTagSyntax)token.Parent;
if (token == startTag.GreaterThanToken && startTag.Name.LocalName.ValueText == "list")
{
items.AddRange(GetListItems(engine, span));
}
if (token == startTag.GreaterThanToken && startTag.Name.LocalName.ValueText == "listheader")
{
items.AddRange(GetListHeaderItems(engine, span));
}
}
items.AddRange(GetAlwaysVisibleItems(engine, span));
return(items);
}
protected IEnumerable <CompletionData> GetListHeaderItems(CompletionEngine engine, TextSpan span)
{
return(new[] { "term", "description" }
.Select(t => GetItem(engine, t, span)));
}
IEnumerable<CompletionData> GetFormatCompletionForType(CompletionEngine engine, ITypeSymbol type)
{
if (type == null) {
return GenerateNumberFormatitems (engine, false)
.Concat (GenerateDateTimeFormatitems (engine))
.Concat (GenerateTimeSpanFormatitems (engine))
.Concat (GenerateEnumFormatitems (engine))
.Concat (GenerateGuidFormatitems (engine));
}
switch (type.ToString()) {
case "long":
case "System.Int64":
case "ulong":
case "System.UInt64":
case "int":
case "System.Int32":
case "uint":
case "System.UInt32":
case "short":
case "System.Int16":
case "ushort":
case "System.UInt16":
case "byte":
case "System.Byte":
case "sbyte":
case "System.SByte":
return GenerateNumberFormatitems(engine, false);
case "float":
case "System.Single":
case "double":
case "System.Double":
case "decimal":
case "System.Decimal":
return GenerateNumberFormatitems(engine, true);
case "System.Enum":
return GenerateEnumFormatitems(engine);
case "System.DateTime":
return GenerateDateTimeFormatitems(engine);
case "System.TimeSpan":
return GenerateTimeSpanFormatitems(engine);
case "System.Guid":
return GenerateGuidFormatitems(engine);
}
return CompletionResult.Empty;
}
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
var tree = await completionContext.Document.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree.IsInNonUserCode(completionContext.Position, cancellationToken) ||
tree.IsPreProcessorDirectiveContext(completionContext.Position, cancellationToken) ||
info.CompletionTriggerReason != CompletionTriggerReason.CompletionCommand)
{
return(Enumerable.Empty <CompletionData>());
}
var token = tree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken);
if (token.Span.End == completionContext.Position)
{
return(Enumerable.Empty <CompletionData>());
}
var parent = token.Parent.AncestorsAndSelf().OfType <GenericNameSyntax> ().FirstOrDefault() ?? token.Parent;
if (!parent.Parent.IsKind(SyntaxKind.IncompleteMember) &&
!IsLocal(parent) &&
!parent.Parent.IsKind(SyntaxKind.Parameter) &&
!parent.Parent.IsKind(SyntaxKind.ForEachStatement))
{
return(Enumerable.Empty <CompletionData>());
}
if (info.TriggerCharacter != ' ' &&
parent.Parent.IsKind(SyntaxKind.ExpressionStatement))
{
return(Enumerable.Empty <CompletionData>());
}
var list = new List <CompletionData> ();
if (parent.IsKind(SyntaxKind.PredefinedType))
{
switch (token.Kind())
{
case SyntaxKind.ObjectKeyword:
list.Add(engine.Factory.CreateGenericData(this, "o", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "obj", GenericDataType.NameProposal));
return(list);
case SyntaxKind.BoolKeyword:
list.Add(engine.Factory.CreateGenericData(this, "b", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "pred", GenericDataType.NameProposal));
return(list);
case SyntaxKind.CharKeyword:
list.Add(engine.Factory.CreateGenericData(this, "c", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "ch", GenericDataType.NameProposal));
return(list);
case SyntaxKind.StringKeyword:
list.Add(engine.Factory.CreateGenericData(this, "str", GenericDataType.NameProposal));
return(list);
case SyntaxKind.DoubleKeyword:
case SyntaxKind.FloatKeyword:
case SyntaxKind.DecimalKeyword:
list.Add(engine.Factory.CreateGenericData(this, "d", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "f", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "m", GenericDataType.NameProposal));
return(list);
default:
list.Add(engine.Factory.CreateGenericData(this, "i", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "j", GenericDataType.NameProposal));
list.Add(engine.Factory.CreateGenericData(this, "k", GenericDataType.NameProposal));
return(list);
}
}
else
{
var incompleteMember = parent.Parent as IncompleteMemberSyntax;
if (incompleteMember != null)
{
return(list);
}
var gns = parent as GenericNameSyntax;
var names = WordParser.BreakWords(gns != null ? gns.Identifier.ToString() : token.ToString().Trim());
var possibleName = new StringBuilder();
for (int i = 0; i < names.Count; i++)
{
possibleName.Length = 0;
for (int j = i; j < names.Count; j++)
{
if (string.IsNullOrEmpty(names [j]))
{
continue;
}
if (j == i)
{
names [j] = Char.ToLower(names [j] [0]) + names [j].Substring(1);
}
possibleName.Append(names [j]);
}
list.Add(engine.Factory.CreateGenericData(this, possibleName.ToString(), GenericDataType.NameProposal));
}
}
return(list);
}
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
{
// var ctx = await completionContext.GetSyntaxContextAsync (engine.Workspace, cancellationToken).ConfigureAwait (false);
var document = completionContext.Document;
var semanticModel = ctx.SemanticModel;
var tree = ctx.SyntaxTree;
if (tree.IsInNonUserCode(completionContext.Position, cancellationToken))
{
return(Enumerable.Empty <CompletionData> ());
}
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var startLineNumber = text.Lines.IndexOf(completionContext.Position);
// modifiers* override modifiers* type? |
Accessibility seenAccessibility;
//DeclarationModifiers modifiers;
var token = tree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken);
if (token.Parent == null)
{
return(Enumerable.Empty <CompletionData> ());
}
var parentMember = token.Parent.AncestorsAndSelf().OfType <MemberDeclarationSyntax> ().FirstOrDefault(m => !m.IsKind(SyntaxKind.IncompleteMember));
if (!(parentMember is BaseTypeDeclarationSyntax) &&
/* May happen in case:
*
* override $
* public override string Foo () {}
*/
!(token.IsKind(SyntaxKind.OverrideKeyword) && token.Span.Start <= parentMember.Span.Start))
{
return(Enumerable.Empty <CompletionData> ());
}
var position = completionContext.Position;
var startToken = token.GetPreviousTokenIfTouchingWord(position);
ITypeSymbol returnType;
SyntaxToken tokenBeforeReturnType;
TryDetermineReturnType(startToken, semanticModel, cancellationToken, out returnType, out tokenBeforeReturnType);
if (returnType == null)
{
var enclosingType = semanticModel.GetEnclosingSymbol(position, cancellationToken) as INamedTypeSymbol;
if (enclosingType != null && (startToken.IsKind(SyntaxKind.OpenBraceToken) || startToken.IsKind(SyntaxKind.CloseBraceToken) || startToken.IsKind(SyntaxKind.SemicolonToken)))
{
return(CreateCompletionData(engine, semanticModel, position, returnType, Accessibility.NotApplicable, startToken, tokenBeforeReturnType, false, cancellationToken));
}
}
if (!TryDetermineModifiers(ref tokenBeforeReturnType, text, startLineNumber, out seenAccessibility /*, out modifiers*/) ||
!TryCheckForTrailingTokens(tree, text, startLineNumber, position, cancellationToken))
{
return(Enumerable.Empty <CompletionData> ());
}
return(CreateCompletionData(engine, semanticModel, position, returnType, seenAccessibility, startToken, tokenBeforeReturnType, true, cancellationToken));
}
IEnumerable<CompletionData> GenerateTimeSpanFormatitems(CompletionEngine engine)
{
yield return engine.Factory.CreateFormatItemCompletionData(this, "c", "invariant", new TimeSpan(0, 1, 23, 456));
yield return engine.Factory.CreateFormatItemCompletionData(this, "G", "general long", new TimeSpan(0, 1, 23, 456));
yield return engine.Factory.CreateFormatItemCompletionData(this, "g", "general short", new TimeSpan(0, 1, 23, 456));
}
protected 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 Task.FromResult (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 != null && parent.IsKind (SyntaxKind.CatchDeclaration) ||
parent.IsKind (SyntaxKind.QualifiedName) && parent.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));
ISymbol categorySymbol;
var method = symbol as IMethodSymbol;
if (method != null) {
if (method.IsReducedExtension ()) {
categorySymbol = method.ReceiverType;
} else {
categorySymbol = (ISymbol)symbol.ContainingType;
}
} else {
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 Task.FromResult ((IEnumerable<CompletionData>)result);
}
IEnumerable<CompletionData> GenerateGuidFormatitems(CompletionEngine engine)
{
yield return engine.Factory.CreateFormatItemCompletionData(this, "N", "digits", defaultGuid);
yield return engine.Factory.CreateFormatItemCompletionData(this, "D", "hypens", defaultGuid);
yield return engine.Factory.CreateFormatItemCompletionData(this, "B", "braces", defaultGuid);
yield return engine.Factory.CreateFormatItemCompletionData(this, "P", "parentheses", defaultGuid);
}
protected IEnumerable <CompletionData> GetNestedTags(CompletionEngine engine, TextSpan filterSpan)
{
return(new[] { "c", "code", "para", "list", "paramref", "typeparamref" }
.Select(t => GetItem(engine, t, filterSpan)));
}
IEnumerable<CompletionData> GetFormatCompletionData(CompletionEngine engine, SemanticModel semanticModel, InvocationExpressionSyntax invocationExpression, int formatArgument, char currentChar)
{
var symbolInfo = semanticModel.GetSymbolInfo (invocationExpression);
var method = symbolInfo.Symbol as IMethodSymbol ?? symbolInfo.CandidateSymbols.OfType<IMethodSymbol> ().FirstOrDefault ();
var ma = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (ma != null && ma.Name.ToString () == "ToString") {
if (method == null || currentChar != '"') {
return Enumerable.Empty<CompletionData> ();
}
if (method != null) {
return GetFormatCompletionForType (engine, method.ContainingType);
} else {
return Enumerable.Empty<CompletionData> ();
}
} else {
if(method == null || currentChar != ':') {
return Enumerable.Empty<CompletionData> ();
}
ExpressionSyntax fmtArgumets;
IList<ExpressionSyntax> args;
if (FormatStringHelper.TryGetFormattingParameters(semanticModel, invocationExpression, out fmtArgumets, out args, null)) {
ITypeSymbol type = null;
if (formatArgument + 1< args.Count) {
var invokeArgument = semanticModel.GetSymbolInfo(args[formatArgument + 1]);
if (invokeArgument.Symbol != null)
type = invokeArgument.Symbol.GetReturnType();
}
return GetFormatCompletionForType(engine, type);
}
}
return Enumerable.Empty<CompletionData> ();
}
protected IEnumerable <CompletionData> GetTopLevelRepeatableItems(CompletionEngine engine, TextSpan filterSpan)
{
return(new[] { "exception", "include", "permission" }
.Select(t => GetItem(engine, t, filterSpan)));
}
protected IEnumerable <CompletionData> GetAlwaysVisibleItems(CompletionEngine engine, TextSpan filterSpan)
{
return(new[] { "see", "seealso", "