public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var items = await this.GetItemsAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
var builder = await this.GetBuilderAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
if (items == null && builder == null)
{
return;
}
if (items != null)
{
foreach (var item in items)
{
context.AddItem(item);
}
}
if (builder != null)
{
context.RegisterBuilder(builder);
}
var isExclusive = await this.IsExclusiveAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
context.MakeExclusive(isExclusive);
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var options = context.Options;
var cancellationToken = context.CancellationToken;
if (!options.GetOption(CompletionOptions.IncludeKeywords, document.Project.Language))
{
return;
}
using (Logger.LogBlock(FunctionId.Completion_KeywordCompletionProvider_GetItemsWorker, cancellationToken))
{
var keywords = await document.GetUnionItemsFromDocumentAndLinkedDocumentsAsync(
s_comparer,
(doc, ct) => RecommendKeywordsAsync(doc, position, ct),
cancellationToken).ConfigureAwait(false);
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = this.GetTextChangeSpan(text, position);
foreach (var keyword in keywords)
{
context.AddItem(CreateItem(keyword, filterSpan));
}
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var items = await this.GetItemsAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
var builder = await this.GetBuilderAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
if (items == null && builder == null)
{
return;
}
if (items != null)
{
foreach (var item in items)
{
context.AddItem(item);
}
}
if (builder != null)
{
context.RegisterBuilder(builder);
}
var isExclusive = await this.IsExclusiveAsync(context.Document, context.Position, context.TriggerInfo, context.CancellationToken).ConfigureAwait(false);
context.MakeExclusive(isExclusive);
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var workspace = document.Project.Solution.Workspace;
var semanticModel = await document.GetSemanticModelForSpanAsync(new TextSpan(position, length : 0), cancellationToken).ConfigureAwait(false);
var typeAndLocation = GetInitializedType(document, semanticModel, position, cancellationToken);
if (typeAndLocation == null)
{
return;
}
var initializedType = typeAndLocation.Item1 as INamedTypeSymbol;
var initializerLocation = typeAndLocation.Item2;
if (initializedType == null)
{
return;
}
if (await IsExclusiveAsync(document, position, cancellationToken).ConfigureAwait(false))
{
context.MakeExclusive(true);
}
var enclosing = semanticModel.GetEnclosingNamedTypeOrAssembly(position, cancellationToken);
// Find the members that can be initialized. If we have a NamedTypeSymbol, also get the overridden members.
IEnumerable <ISymbol> members = semanticModel.LookupSymbols(position, initializedType);
members = members.Where(m => IsInitializable(m, initializedType) &&
m.CanBeReferencedByName &&
IsLegalFieldOrProperty(m, enclosing) &&
!m.IsImplicitlyDeclared);
// Filter out those members that have already been typed
var alreadyTypedMembers = GetInitializedMembers(semanticModel.SyntaxTree, position, cancellationToken);
var uninitializedMembers = members.Where(m => !alreadyTypedMembers.Contains(m.Name));
uninitializedMembers = uninitializedMembers.Where(m => m.IsEditorBrowsable(document.ShouldHideAdvancedMembers(), semanticModel.Compilation));
var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = GetTextChangeSpan(text, position);
foreach (var uninitializedMember in uninitializedMembers)
{
context.AddItem(CreateItem(
workspace,
uninitializedMember.Name,
filterSpan,
CommonCompletionUtilities.CreateDescriptionFactory(workspace, semanticModel, initializerLocation.SourceSpan.Start, uninitializedMember),
uninitializedMember.GetGlyph()));
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var workspace = document.Project.Solution.Workspace;
var semanticModel = await document.GetSemanticModelForSpanAsync(new TextSpan(position, length: 0), cancellationToken).ConfigureAwait(false);
var typeAndLocation = GetInitializedType(document, semanticModel, position, cancellationToken);
if (typeAndLocation == null)
{
return;
}
var initializedType = typeAndLocation.Item1 as INamedTypeSymbol;
var initializerLocation = typeAndLocation.Item2;
if (initializedType == null)
{
return;
}
if (await IsExclusiveAsync(document, position, cancellationToken).ConfigureAwait(false))
{
context.MakeExclusive(true);
}
var enclosing = semanticModel.GetEnclosingNamedTypeOrAssembly(position, cancellationToken);
// Find the members that can be initialized. If we have a NamedTypeSymbol, also get the overridden members.
IEnumerable<ISymbol> members = semanticModel.LookupSymbols(position, initializedType);
members = members.Where(m => IsInitializable(m, initializedType) &&
m.CanBeReferencedByName &&
IsLegalFieldOrProperty(m, enclosing) &&
!m.IsImplicitlyDeclared);
// Filter out those members that have already been typed
var alreadyTypedMembers = GetInitializedMembers(semanticModel.SyntaxTree, position, cancellationToken);
var uninitializedMembers = members.Where(m => !alreadyTypedMembers.Contains(m.Name));
uninitializedMembers = uninitializedMembers.Where(m => m.IsEditorBrowsable(document.ShouldHideAdvancedMembers(), semanticModel.Compilation));
var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = GetTextChangeSpan(text, position);
foreach (var uninitializedMember in uninitializedMembers)
{
context.AddItem(CreateItem(
workspace,
uninitializedMember.Name,
filterSpan,
CommonCompletionUtilities.CreateDescriptionFactory(workspace, semanticModel, initializerLocation.SourceSpan.Start, uninitializedMember),
uninitializedMember.GetGlyph()));
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree.IsInNonUserCode(position, cancellationToken))
{
return;
}
var targetToken = tree
.FindTokenOnLeftOfPosition(position, cancellationToken)
.GetPreviousTokenIfTouchingWord(position);
if (targetToken.IsKind(SyntaxKind.AliasKeyword) && targetToken.Parent.IsKind(SyntaxKind.ExternAliasDirective))
{
var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var aliases = compilation.ExternalReferences.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);
aliases.RemoveRange(usedAliases);
aliases.Remove(MetadataReferenceProperties.GlobalAlias);
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = CompletionUtilities.GetTextChangeSpan(text, position);
foreach (var alias in aliases)
{
context.AddItem(new CompletionItem(this, alias, filterSpan, glyph: Glyph.Namespace));
}
}
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var showSpeculativeT = await document.IsValidContextForDocumentOrLinkedDocumentsAsync(
(doc, ct) => ShouldShowSpeculativeTCompletionItemAsync(doc, position, ct),
cancellationToken).ConfigureAwait(false);
if (showSpeculativeT)
{
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = this.GetTextChangeSpan(text, position);
const string T = "T";
context.AddItem(new CompletionItem(this, T, filterSpan, descriptionFactory: null, glyph: Glyph.TypeParameter));
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
if (document != null && document.SourceCodeKind == SourceCodeKind.Interactive)
{
// the provider might be invoked in non-interactive context:
Workspace ws;
if (Workspace.TryGetWorkspace(document.GetTextAsync(cancellationToken).WaitAndGetResult(cancellationToken).Container, out ws))
{
var workspace = ws as InteractiveWorkspace;
if (workspace != null)
{
var window = workspace.Engine.CurrentWindow;
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree.IsBeforeFirstToken(position, cancellationToken) &&
tree.IsPreProcessorKeywordContext(position, cancellationToken))
{
var filterSpan = await this.GetTextChangeSpanAsync(document, position, cancellationToken).ConfigureAwait(false);
IInteractiveWindowCommands commands = window.GetInteractiveCommands();
if (commands != null)
{
foreach (var command in commands.GetCommands())
{
foreach (var commandName in command.Names)
{
context.AddItem(new CompletionItem(
this, commandName, filterSpan, c => Task.FromResult(command.Description.ToSymbolDisplayParts()), glyph: Glyph.Intrinsic));
}
}
}
}
}
}
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
// the provider might be invoked in non-interactive context:
Workspace ws;
SourceText sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
if (Workspace.TryGetWorkspace(sourceText.Container, out ws))
{
var workspace = ws as InteractiveWorkspace;
if (workspace != null)
{
var window = workspace.Engine.CurrentWindow;
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (await ShouldDisplayCommandCompletionsAsync(tree, position, cancellationToken).ConfigureAwait(false))
{
var filterSpan = await this.GetTextChangeSpanAsync(document, position, cancellationToken).ConfigureAwait(false);
IInteractiveWindowCommands commands = window.GetInteractiveCommands();
if (commands != null)
{
foreach (var command in commands.GetCommands())
{
foreach (var commandName in command.Names)
{
string completion = GetCompletionString(commandName);
context.AddItem(new CompletionItem(
this, completion, filterSpan, c => Task.FromResult(command.Description.ToSymbolDisplayParts()), glyph: Glyph.Intrinsic));
}
}
}
}
}
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
try
{
var document = context.Document;
var position = context.Position;
var options = context.Options;
var cancellationToken = context.CancellationToken;
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree.IsInNonUserCode(position, cancellationToken))
{
return;
}
var token = tree.FindTokenOnLeftOfPosition(position, cancellationToken);
if (token.IsMandatoryNamedParameterPosition())
{
return;
}
var typeInferenceService = document.GetLanguageService <ITypeInferenceService>();
var span = new TextSpan(position, 0);
var semanticModel = await document.GetSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
var type = typeInferenceService.InferType(semanticModel, position,
objectAsDefault: true,
cancellationToken: cancellationToken);
// If we have a Nullable<T>, unwrap it.
if (type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
{
type = type.GetTypeArguments().FirstOrDefault();
if (type == null)
{
return;
}
}
if (type.TypeKind != TypeKind.Enum)
{
type = GetCompletionListType(type, semanticModel.GetEnclosingNamedType(position, cancellationToken), semanticModel.Compilation);
if (type == null)
{
return;
}
}
if (!type.IsEditorBrowsable(options.GetOption(CompletionOptions.HideAdvancedMembers, semanticModel.Language), semanticModel.Compilation))
{
return;
}
// Does type have any aliases?
ISymbol alias = await type.FindApplicableAlias(position, semanticModel, cancellationToken).ConfigureAwait(false);
var displayService = document.GetLanguageService <ISymbolDisplayService>();
var displayText = alias != null
? alias.Name
: displayService.ToMinimalDisplayString(semanticModel, position, type);
var workspace = document.Project.Solution.Workspace;
var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
var textChangeSpan = CompletionUtilities.GetTextChangeSpan(text, position);
var item = new CompletionItem(
this,
displayText: displayText,
filterSpan: textChangeSpan,
descriptionFactory: CommonCompletionUtilities.CreateDescriptionFactory(workspace, semanticModel, position, alias ?? type),
glyph: (alias ?? type).GetGlyph(),
preselect: true,
rules: ItemRules.Instance);
context.AddItem(item);
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsInNonUserCode(position, cancellationToken))
{
return;
}
var token = syntaxTree
.FindTokenOnLeftOfPosition(position, cancellationToken)
.GetPreviousTokenIfTouchingWord(position);
if (!token.IsKind(SyntaxKind.OpenParenToken, SyntaxKind.OpenBracketToken, SyntaxKind.CommaToken))
{
return;
}
var argumentList = token.Parent as BaseArgumentListSyntax;
if (argumentList == null)
{
return;
}
var semanticModel = await document.GetSemanticModelForNodeAsync(argumentList, cancellationToken).ConfigureAwait(false);
var parameterLists = GetParameterLists(semanticModel, position, argumentList.Parent, cancellationToken);
if (parameterLists == null)
{
return;
}
var existingNamedParameters = GetExistingNamedParameters(argumentList, position);
parameterLists = parameterLists.Where(pl => IsValid(pl, existingNamedParameters));
var unspecifiedParameters = parameterLists.SelectMany(pl => pl)
.Where(p => !existingNamedParameters.Contains(p.Name))
.Distinct(this);
if (!unspecifiedParameters.Any())
{
return;
}
if (token.IsMandatoryNamedParameterPosition())
{
context.MakeExclusive(true);
}
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var filterSpan = CompletionUtilities.GetTextChangeSpan(text, position);
var workspace = document.Project.Solution.Workspace;
foreach (var parameter in unspecifiedParameters)
{
// Note: the filter text does not include the ':'. We want to ensure that if
// the user types the name exactly (up to the colon) that it is selected as an
// exact match.
var escapedName = parameter.Name.ToIdentifierToken().ToString();
context.AddItem(new CompletionItem(
this,
escapedName + ColonString,
filterSpan,
CommonCompletionUtilities.CreateDescriptionFactory(workspace, semanticModel, token.SpanStart, parameter),
parameter.GetGlyph(),
sortText: parameter.Name,
filterText: escapedName,
rules: ItemRules.Instance));
}
}
public override async Task ProduceCompletionListAsync(CompletionListContext context)
{
var document = context.Document;
var position = context.Position;
var options = context.Options;
var cancellationToken = context.CancellationToken;
var span = new TextSpan(position, length: 0);
var semanticModel = await document.GetSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
var syntaxTree = semanticModel.SyntaxTree;
var syntaxFacts = document.GetLanguageService <ISyntaxFactsService>();
var semanticFacts = document.GetLanguageService <ISemanticFactsService>();
if (syntaxFacts.IsInNonUserCode(syntaxTree, position, cancellationToken) ||
semanticFacts.IsPreProcessorDirectiveContext(semanticModel, position, cancellationToken))
{
return;
}
if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken))
{
return;
}
var node = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken)
.GetPreviousTokenIfTouchingWord(position)
.Parent;
if (node.Kind() != SyntaxKind.ExplicitInterfaceSpecifier)
{
return;
}
// Bind the interface name which is to the left of the dot
var name = ((ExplicitInterfaceSpecifierSyntax)node).Name;
var symbol = semanticModel.GetSymbolInfo(name, cancellationToken).Symbol as ITypeSymbol;
if (symbol?.TypeKind != TypeKind.Interface)
{
return;
}
var members = semanticModel.LookupSymbols(
position: name.SpanStart,
container: symbol)
.Where(s => !s.IsStatic)
.FilterToVisibleAndBrowsableSymbols(options.GetOption(CompletionOptions.HideAdvancedMembers, semanticModel.Language), semanticModel.Compilation);
// We're going to create a entry for each one, including the signature
var namePosition = name.SpanStart;
var text = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
var textChangeSpan = CompletionUtilities.GetTextChangeSpan(text, position);
foreach (var member in members)
{
var displayText = member.ToMinimalDisplayString(semanticModel, namePosition, s_signatureDisplayFormat);
var insertionText = displayText;
context.AddItem(new SymbolCompletionItem(
this,
displayText,
insertionText: insertionText,
filterSpan: textChangeSpan,
position: position,
symbols: new List <ISymbol> {
member
},
context: CSharpSyntaxContext.CreateContext(document.Project.Solution.Workspace, semanticModel, position, cancellationToken),
rules: ItemRules.Instance));
}
}