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); }
public IEnumerable<Completion> GetCompletionEntries(CompletionContext context) { ImageSource imageSource = GetImageSource(); var group = "Main"; try { var text = context.Snapshot.GetText().Substring(0, context.SpanStart + context.SpanLength); var lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); for (int i = lines.Length - 1; i >= 0; i--) { var line = lines[i].Trim(); if (line.StartsWith("group")) group = line.Replace("group", "").Trim(); } } catch (Exception) { } var searchResults = Paket.Dependencies.Locate(context.Snapshot.TextBuffer.GetFileName()) .GetInstalledPackages() .Where(x => Paket.Domain.GroupName(x.Item1).Equals(Paket.Domain.GroupName(group))) .Select(x => x.Item2) .ToArray(); foreach (var value in searchResults) { yield return new Completion2(value, value, null, imageSource, "iconAutomationText"); } }
protected virtual CompletionContext GetCompletionContext(IEditorView view) { var reader = view.GetReader(); var token = reader.ReadTokenReverse(); var completionContext = new CompletionContext(); if (token == null) return completionContext; var tokenText = reader.PeekText(token.Length); if (token.Key == "Identifier" || (token.Key == "Punctuation" && tokenText == ".")) { var memberExpression = DetermineFullMemberExpression(tokenText, reader); if (memberExpression.Contains(".")) completionContext.IsObjectMember = true; if (memberExpression.StartsWith("this.")) { completionContext.IsDocumentProperty = true; var completedPath = memberExpression.Substring("this.".Length); var lastDot = completedPath.LastIndexOf('.'); completedPath = lastDot >= 0 ? completedPath.Substring(0, lastDot) : ""; completionContext.CompletedPropertyPath = completedPath; } } return completionContext; }
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 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> (); }
public IEnumerable<Completion> GetCompletionEntries(CompletionContext context) { ImageSource imageSource = GetImageSource(); if (searchResults != null) { foreach (var value in searchResults) { yield return new Completion2(value, value, null, imageSource, "iconAutomationText"); } searchResults = null; } else { Action<CompletionEntry> action = entry => { string searchTerm = context.Snapshot.GetText(context.SpanStart, context.SpanLength); entry.UpdateDisplayText(searchTerm); ExecuteSearch(searchTerm); }; yield return new CompletionEntry("Search remote NuGet packages...", null, null, imageSource, commitAction: action); } }
public async sealed override Task ProvideCompletionsAsync(CompletionContext completionContext) { var document = completionContext.Document; var position = completionContext.Position; var cancellationToken = completionContext.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var node = GetPartialTypeSyntaxNode(tree, position, cancellationToken); if (node != null) { var semanticModel = await document.GetSemanticModelForNodeAsync(node, cancellationToken).ConfigureAwait(false); var syntaxContext = await CreateSyntaxContextAsync(document, semanticModel, position, cancellationToken).ConfigureAwait(false); var declaredSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken) as INamedTypeSymbol; if (declaredSymbol != null) { var symbols = LookupCandidateSymbols(syntaxContext, declaredSymbol, cancellationToken); var items = symbols?.Select(s => CreateCompletionItem(s, syntaxContext)); if (items != null) { completionContext.AddItems(items); } } } }
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> (); }
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> (); }
public IEnumerable<Completion> GetCompletionEntries(CompletionContext context) { var feeds = Paket.Dependencies.Locate().GetDefinedNuGetFeeds(); foreach (var feed in feeds) { yield return new Completion2(feed, feed, null, null, "iconAutomationText"); } }
private void ExecuteSearch(CompletionContext context, string searchTerm) { ThreadPool.QueueUserWorkItem(state => { DteHelper.ExecuteCommand("Edit.CompleteWord"); }); }
public override async Task<bool> IsExclusiveAsync (CompletionContext completionContext, SyntaxContext syntaxContext, CompletionTriggerInfo triggerInfo, CancellationToken cancellationToken) { // We're exclusive if this context could only be an object initializer and not also a // collection initializer. If we're initializing something that could be initialized as // an object or as a collection, say we're not exclusive. That way the rest of // intellisense can be used in the collection intitializer. // // Consider this case: // class c : IEnumerable<int> // { // public void Add(int addend) { } // public int foo; // } // void foo() // { // var b = new c {| // } // There we could initialize b using either an object initializer or a collection // initializer. Since we don't know which the user will use, we'll be non-exclusive, so // the other providers can help the user write the collection initializer, if they want // to. var document = completionContext.Document; var position = completionContext.Position; var tree = await document.GetCSharpSyntaxTreeAsync (cancellationToken).ConfigureAwait (false); if (tree.IsInNonUserCode (position, cancellationToken)) { return false; } var token = tree.FindTokenOnLeftOfPosition (position, cancellationToken); token = token.GetPreviousTokenIfTouchingWord (position); if (token.Parent == null) { return false; } var expression = token.Parent.Parent as ExpressionSyntax; if (expression == null) { return false; } var semanticModel = await document.GetCSharpSemanticModelForNodeAsync (expression, cancellationToken).ConfigureAwait (false); var initializedType = semanticModel.GetTypeInfo (expression, cancellationToken).Type; if (initializedType == null) { return false; } // Non-exclusive if initializedType can be initialized as a collection. if (initializedType.CanSupportCollectionInitializer ()) { return false; } // By default, only our member names will show up. return true; }
public override async Task ProvideCompletionsAsync(CompletionContext 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.IsExclusive = true; } var enclosing = semanticModel.GetEnclosingNamedType(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, enclosing) && 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); foreach (var uninitializedMember in uninitializedMembers) { context.AddItem(SymbolCompletionItem.Create( displayText: uninitializedMember.Name, insertionText: null, span: context.DefaultItemSpan, symbol: uninitializedMember, descriptionPosition: initializerLocation.SourceSpan.Start, rules: s_rules )); } }
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); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var state = await ItemGetter.CreateAsync(this, context.Document, context.Position, context.CancellationToken).ConfigureAwait(false); var items = await state.GetItemsAsync().ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (context.Options.GetOption(CompletionControllerOptions.AlwaysShowBuilder)) { var text = await context.Document.GetTextAsync(context.CancellationToken).ConfigureAwait(false); context.SuggestionModeItem = this.CreateEmptySuggestionModeItem(context.DefaultItemSpan); } else { context.SuggestionModeItem = await this.GetSuggestionModeItemAsync(context.Document, context.Position, context.DefaultItemSpan, context.Trigger, context.CancellationToken).ConfigureAwait(false); } }
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>(); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { if (!context.Options.GetOption(CompletionControllerOptions.ShowXmlDocCommentCompletion)) { return; } var items = await GetItemsWorkerAsync(context.Document, context.Position, context.DefaultItemSpan, context.Trigger, context.CancellationToken).ConfigureAwait(false); if (items != null) { context.AddItems(items); } }
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; }
public IEnumerable<Completion> GetCompletionEntries(CompletionContext context) { ImageSource imageSource = GetImageSource(); var searchResults = Paket.Dependencies.Locate(context.Snapshot.TextBuffer.GetFileName()) .GetInstalledPackages().Select(x => x.Item1); foreach (var value in searchResults) { yield return new Completion2(value, value, null, imageSource, "iconAutomationText"); } }
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); }
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); }
public IEnumerable<Completion> GetCompletionEntries(CompletionContext context) { ImageSource imageSource = GetImageSource(); string searchTerm = context.Snapshot.GetText(context.SpanStart, context.SpanLength); var searchResults = FSharpAsync.RunSynchronously( NuGetV3.FindPackages(FSharpOption<Paket.PackageSources.NugetSourceAuthentication>.None, Constants.DefaultNuGetStream, searchTerm, 20), FSharpOption<int>.None, FSharpOption<CancellationToken>.None); foreach (var value in searchResults) { yield return new Completion2(value, value, null, imageSource, "iconAutomationText"); } }
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 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; }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var document = context.Document; var position = context.Position; var cancellationToken = context.CancellationToken; var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); if (!IsPartialMethodCompletionContext(tree, position, cancellationToken, out var modifiers, out var token)) { return; } var items = await CreatePartialItemsAsync( document, position, context.CompletionListSpan, modifiers, token, cancellationToken).ConfigureAwait(false); if (items?.Any() == true) { context.IsExclusive = true; context.AddItems(items); } }
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; }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.ShowTypeParameterConstraints = false; b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~(Modifiers.Virt | Modifiers.Abstract); entityDeclaration.Modifiers |= Modifiers.Override; var body = entityDeclaration.GetChildByRole(Roles.Body); Statement baseCallStatement = body.Children.OfType <Statement>().FirstOrDefault(); if (!this.Entity.IsAbstract) { // modify body to call the base method if (this.Entity.SymbolKind == SymbolKind.Method) { var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, new Expression[] { }); if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void)) { baseCallStatement = new ExpressionStatement(baseCall); } else { baseCallStatement = new ReturnStatement(baseCall); } // Clear body of inserted method entityDeclaration.GetChildByRole(Roles.Body).Statements.Clear(); } } var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = AlFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject()); var segmentDict = SegmentTrackingOutputFormatter.WriteNode( w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options); using (document.OpenUndoGroup()) { InsertionContext insertionContext = new InsertionContext(context.Editor.GetService(typeof(TextArea)) as TextArea, declarationBegin); insertionContext.InsertionPosition = context.Editor.Caret.Offset; string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } AlFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions.OptionsContainer); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); var typeResolveContext = refactoringContext.GetTypeResolveContext(); if (typeResolveContext == null) { return; } var resolvedCurrent = typeResolveContext.CurrentTypeDefinition; IEditorUIService uiService = context.Editor.GetService(typeof(IEditorUIService)) as IEditorUIService; ITextAnchor endAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); endAnchor.MovementType = AnchorMovementType.AfterInsertion; ITextAnchor startAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); startAnchor.MovementType = AnchorMovementType.BeforeInsertion; ITextAnchor insertionPos = context.Editor.Document.CreateAnchor(endAnchor.Offset); insertionPos.MovementType = AnchorMovementType.BeforeInsertion; var current = typeResolveContext.CurrentTypeDefinition; AbstractInlineRefactorDialog dialog = new OverrideEqualsGetHashCodeMethodsDialog(insertionContext, context.Editor, endAnchor, insertionPos, current, Entity as IMethod, baseCallStatement); dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog); insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog); insertionContext.RaiseInsertionCompleted(EventArgs.Empty); } }
public override async Task ProvideCompletionsAsync(CompletionContext 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) .GetPreviousTokenIfTouchingWord(position); if (token.IsMandatoryNamedParameterPosition()) { return; } // Don't show up within member access // This previously worked because the type inferrer didn't work // in member access expressions. // The regular SymbolCompletionProvider will handle completion after . if (token.IsKind(SyntaxKind.DotToken)) { return; } var typeInferenceService = document.GetLanguageService <ITypeInferenceService>(); Contract.ThrowIfNull(typeInferenceService, nameof(typeInferenceService)); 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 = TryGetEnumTypeInEnumInitializer(semanticModel, token, type, cancellationToken) ?? TryGetCompletionListType(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? var 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 item = SymbolCompletionItem.CreateWithSymbolId( displayText: displayText, symbols: ImmutableArray.Create(alias ?? type), rules: s_rules.WithMatchPriority(MatchPriority.Preselect), contextPosition: position); context.AddItem(item); } catch (Exception e) when(FatalError.ReportUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } }
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); }
private async Task AddCompletionItemsAsync(CompletionContext completionContext, SyntaxContext syntaxContext, TelemetryCounter telemetryCounter, CancellationToken cancellationToken) { var document = completionContext.Document; var project = document.Project; var workspace = project.Solution.Workspace; var typeImportCompletionService = document.GetLanguageService <ITypeImportCompletionService>(); // Find all namespaces in scope at current cursor location, // which will be used to filter so the provider only returns out-of-scope types. var namespacesInScope = GetNamespacesInScope(document, syntaxContext, cancellationToken); // Get completion items from current project. var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); await typeImportCompletionService.GetTopLevelTypesAsync(project, syntaxContext, HandlePublicAndInternalItem, cancellationToken) .ConfigureAwait(false); // Get declarations from directly referenced projects and PEs var referencedAssemblySymbols = compilation.GetReferencedAssemblySymbols(); foreach (var assembly in referencedAssemblySymbols) { cancellationToken.ThrowIfCancellationRequested(); // Skip reference with only non-global alias. var metadataReference = compilation.GetMetadataReference(assembly); if (metadataReference.Properties.Aliases.IsEmpty || metadataReference.Properties.Aliases.Any(alias => alias == MetadataReferenceProperties.GlobalAlias)) { var assemblyProject = project.Solution.GetProject(assembly, cancellationToken); if (assemblyProject != null && assemblyProject.SupportsCompilation) { await typeImportCompletionService.GetTopLevelTypesAsync( assemblyProject, syntaxContext, GetHandler(compilation.Assembly, assembly), cancellationToken).ConfigureAwait(false); } else if (metadataReference is PortableExecutableReference peReference) { typeImportCompletionService.GetTopLevelTypesFromPEReference( project.Solution, compilation, peReference, syntaxContext, GetHandler(compilation.Assembly, assembly), cancellationToken); } } } telemetryCounter.ReferenceCount = referencedAssemblySymbols.Length; return; // Decide which item handler to use based on IVT Action <CompletionItem, bool> GetHandler(IAssemblySymbol assembly, IAssemblySymbol referencedAssembly) => assembly.IsSameAssemblyOrHasFriendAccessTo(referencedAssembly) ? (Action <CompletionItem, bool>)HandlePublicAndInternalItem : HandlePublicItem; // Add only public types to completion list void HandlePublicItem(CompletionItem item, bool isPublic) => AddItems(item, isPublic, isInternalsVisible: false, completionContext, namespacesInScope, telemetryCounter); // Add both public and internal types to completion list void HandlePublicAndInternalItem(CompletionItem item, bool isPublic) => AddItems(item, isPublic, isInternalsVisible: true, completionContext, namespacesInScope, telemetryCounter);
private static void GetGlobalCompletions(SemanticModel semanticModel, SourceLocation position, CompletionContext context) { var symbols = semanticModel.LookupSymbols(position) .Where(x => !(x is SemanticSymbol)) .Where(x => !(x is AttributeSymbol)) .Where(x => x.Locations.Length == 0 || x.Locations.Any(l => l.End < position)); if (!((SyntaxTree)semanticModel.SyntaxTree).PossiblyInTypeName(position)) { symbols = symbols.Where(x => !(x is TypeSymbol)); } CreateSymbolCompletions(symbols.Cast <Symbol>(), context); }
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.IsKind(SyntaxKind.DotToken) || 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); }
void AddDelegateHandlers(CompletionContext context, SyntaxNode parent, SemanticModel semanticModel, ITypeSymbol delegateType, int position, string optDelegateName, CancellationToken cancellationToken) { var delegateMethod = delegateType.GetDelegateInvokeMethod(); string EolMarker = "\n"; bool addSemicolon = true; bool addDefault = true; string delegateEndString = EolMarker + thisLineIndentMarker + "}" + (addSemicolon ? ";" : ""); CompletionItem item; if (addDefault) { item = CreateCompletionItem( "delegate", "Creates anonymous delegate.", "delegate {" + EolMarker + thisLineIndentMarker + eolMarker, delegateEndString, position ); if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item); } //if (LanguageVersion.Major >= 5) item = CreateCompletionItem( "async delegate", "Creates anonymous async delegate.", "async delegate {" + EolMarker + thisLineIndentMarker + eolMarker, delegateEndString, position ); if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item); } } var sb = StringBuilderCache.Allocate("("); var sbWithoutTypes = StringBuilderCache.Allocate("("); for (int k = 0; k < delegateMethod.Parameters.Length; k++) { if (k > 0) { sb.Append(", "); sbWithoutTypes.Append(", "); } sb.Append(CSharpAmbience.SafeMinimalDisplayString(delegateMethod.Parameters [k], semanticModel, position, overrideNameFormat)); sbWithoutTypes.Append(delegateMethod.Parameters [k].Name); } sb.Append(")"); sbWithoutTypes.Append(")"); var signature = StringBuilderCache.ReturnAndFree(sb) .Replace(", params ", ", ") .Replace("(params ", "("); if (context.Items.All(data => data.DisplayText != signature)) { item = CreateCompletionItem( signature + " =>", "Creates typed lambda expression.", signature + " => ", (addSemicolon ? ";" : ""), position ); //item.CompletionCategory = category; if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item); } // if (LanguageVersion.Major >= 5) { item = CreateCompletionItem( "async " + signature + " =>", "Creates typed async lambda expression.", "async " + signature + " => ", (addSemicolon ? ";" : ""), position ); //item.CompletionCategory = category; if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item); } var signatureWithoutTypes = sbWithoutTypes.ToString(); if (!delegateMethod.Parameters.Any(p => p.RefKind != RefKind.None) && context.Items.All(data => data.DisplayText != signatureWithoutTypes)) { item = CreateCompletionItem( signatureWithoutTypes + " =>", "Creates typed lambda expression.", signatureWithoutTypes + " => ", (addSemicolon ? ";" : ""), position ); //item.CompletionCategory = category; if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item.WithRules(item.Rules.WithMatchPriority(int.MaxValue))); } //if (LanguageVersion.Major >= 5) { item = CreateCompletionItem( "async " + signatureWithoutTypes + " =>", "Creates typed async lambda expression.", "async " + signatureWithoutTypes + " => ", (addSemicolon ? ";" : ""), position ); //item.CompletionCategory = category; if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item); } //} } } StringBuilderCache.Free(sbWithoutTypes); item = CreateNewMethodCreationItem(parent, semanticModel, delegateType, position, optDelegateName, delegateMethod, cancellationToken); // item.CompletionCategory = category; if (!context.Items.Any(i => i.DisplayText == item.DisplayText)) { context.AddItem(item.WithRules(item.Rules.WithMatchPriority(int.MaxValue))); } }
public async Task <CompletionResult> GetCompletionDataAsync(CompletionContext completionContext, CompletionTriggerInfo info, CancellationToken cancellationToken = default(CancellationToken)) { if (completionContext == null) { throw new ArgumentNullException("completionContext"); } var document = completionContext.Document; var semanticModel = await completionContext.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var position = completionContext.Position; var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); var ctx = await completionContext.GetSyntaxContextAsync(workspace, cancellationToken); ctx.SemanticModel = semanticModel; // case lambda parameter (n1, $ if (ctx.TargetToken.IsKind(SyntaxKind.CommaToken) && ctx.TargetToken.Parent != null && ctx.TargetToken.Parent.Parent != null && ctx.TargetToken.Parent.Parent.IsKind(SyntaxKind.ParenthesizedLambdaExpression)) { return(CompletionResult.Empty); } var result = new CompletionResult { SyntaxContext = ctx }; if (position > 0) { var nonExclusiveHandlers = new List <CompletionContextHandler> (); var exclusiveHandlers = new List <CompletionContextHandler> (); var toRetriggerHandlers = new List <CompletionContextHandler> (); IEnumerable <CompletionContextHandler> handlerList; if (completionContext.UseDefaultContextHandlers) { handlerList = handlers.Concat(completionContext.AdditionalContextHandlers); } else { handlerList = completionContext.AdditionalContextHandlers; } foreach (var handler in handlerList) { if (info.CompletionTriggerReason == CompletionTriggerReason.CompletionCommand || info.CompletionTriggerReason == CompletionTriggerReason.BackspaceOrDeleteCommand || handler.IsTriggerCharacter(text, position - 1)) { if (await handler.IsExclusiveAsync(completionContext, ctx, info, cancellationToken)) { exclusiveHandlers.Add(handler); } else { nonExclusiveHandlers.Add(handler); } } else { toRetriggerHandlers.Add(handler); } } foreach (var handler in exclusiveHandlers) { var handlerResult = await handler.GetCompletionDataAsync(result, this, completionContext, info, ctx, cancellationToken); //if (handlerResult != null) { // Console.WriteLine ("-----" + handler); // foreach (var item in handlerResult) { // Console.WriteLine (item.DisplayText); // } //} else { // Console.WriteLine ("-----" + handler + " == NULL"); //} if (handlerResult != null) { result.AddRange(handlerResult); } } if (result.Count == 0) { foreach (var handler in nonExclusiveHandlers) { var handlerResult = await handler.GetCompletionDataAsync(result, this, completionContext, info, ctx, cancellationToken); //if (handlerResult != null) { // Console.WriteLine ("-----" + handler); // foreach (var item in handlerResult) { // Console.WriteLine (item.DisplayText); // } //} else { // Console.WriteLine ("-----" + handler + " == NULL"); //} if (handlerResult != null && handlerResult.Any()) { result.AddRange(handlerResult); } else { toRetriggerHandlers.Add(handler); } } if (result.Count > 0) { info = info.WithCompletionTriggerReason(CompletionTriggerReason.RetriggerCommand); foreach (var handler in toRetriggerHandlers) { var handlerResult = await handler.GetCompletionDataAsync(result, this, completionContext, info, ctx, cancellationToken); if (handlerResult != null) { result.AddRange(handlerResult); } } } } } // prevent auto selection for "<number>." case if (ctx.TargetToken.IsKind(SyntaxKind.DotToken)) { var accessExpr = ctx.TargetToken.Parent as MemberAccessExpressionSyntax; if (accessExpr != null && accessExpr.Expression != null && accessExpr.Expression.IsKind(SyntaxKind.NumericLiteralExpression)) { result.AutoSelect = false; } } if (ctx.LeftToken.Parent != null && ctx.LeftToken.Parent.Parent != null && ctx.TargetToken.Parent != null && !ctx.TargetToken.Parent.IsKind(SyntaxKind.NameEquals) && ctx.LeftToken.Parent.Parent.IsKind(SyntaxKind.AnonymousObjectMemberDeclarator)) { result.AutoSelect = false; } if (ctx.TargetToken.IsKind(SyntaxKind.OpenParenToken) && ctx.TargetToken.GetPreviousToken().IsKind(SyntaxKind.OpenParenToken)) { var validTypes = TypeGuessing.GetValidTypes(semanticModel, ctx.TargetToken.Parent, cancellationToken); result.AutoSelect = !validTypes.Any(t => t.IsDelegateType()); } foreach (var type in ctx.InferredTypes) { if (type.TypeKind == TypeKind.Delegate) { result.AutoSelect = false; break; } } if (ctx.CSharpSyntaxContext.IsPossibleTupleContext) { result.AutoSelect = false; } return(result); }
public CompletionList Completion(TextDocumentIdentifier textDocument, Position position, CompletionContext context) { return(new CompletionList(PredefinedCompletionItems)); }
public override async Task ProvideCompletionsAsync(CompletionContext context) { var syntaxRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken); if (syntaxRoot == null) { return; } var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken); var node = syntaxRoot.FindNode(context.CompletionListSpan); var argumentSyntaxNode = node.AncestorsAndSelf().OfType <ArgumentSyntax>().FirstOrDefault(); if (argumentSyntaxNode == null) { return; } var lambdaExpression = argumentSyntaxNode.Ancestors().OfType <LambdaExpressionSyntax>().FirstOrDefault(); if (lambdaExpression == null) { return; } var mockMethod = lambdaExpression.Ancestors().FirstOrDefault(x => semanticModel.GetSymbolInfo(x, context.CancellationToken).CandidateSymbols.Any(s => s.ContainingType.Name == "Mock" && s.ContainingAssembly.Name == "Moq")); if (mockMethod == null) { return; } var typingMethod = argumentSyntaxNode.Ancestors().OfType <InvocationExpressionSyntax>().First(); var calingMethod = semanticModel.GetSymbolInfo(typingMethod, context.CancellationToken); if (!(calingMethod.CandidateSymbols[0] is IMethodSymbol callingMethodSymbol)) { return; } var index = argumentSyntaxNode.Parent.ChildNodes().ToList().FindIndex(x => x.Equals(argumentSyntaxNode)); if (index < callingMethodSymbol.Parameters.Length) { context.AddItem(CompletionItem.Create(GetCompletionDisplayText(callingMethodSymbol.Parameters[index].Type), null, null, ImmutableDictionary.Create <string, string>(), ImmutableArray.Create(WellKnownTags.Method), CompletionItemRules.Create(formatOnCommit: true, matchPriority: MatchPriority.Preselect))); } if (index == 0) { context.AddItem(CompletionItem.Create(String.Join(", ", callingMethodSymbol.Parameters.Select(x => GetCompletionDisplayText(x.Type))), null, null, ImmutableDictionary.Create <string, string>(), ImmutableArray.Create(WellKnownTags.Method), CompletionItemRules.Create(formatOnCommit: true))); } }
internal override IEnumerable <PSTypeName> GetInferredType(CompletionContext context) { return(Ast.EmptyPSTypeNameArray); }
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 expr = newExpression; var assignmentParent = expr.Parent as AssignmentExpressionSyntax; // HACK: Work around for a little bug in InferTypes see #41388 - may be obsolete in future roslyn versions. (after 1.2) bool skipInference = false; if (assignmentParent?.Left == expr) { skipInference = true; } if (!skipInference) { var type = SyntaxContext.InferenceService.InferType(ctx.CSharpSyntaxContext.SemanticModel, expr, 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; result.AutoCompleteEmptyMatch = true; } } } for (int i = 0; i < primitiveTypesKeywords.Length; i++) { var keyword = primitiveTypesKeywords [i]; list.Add(engine.Factory.CreateKeywordCompletion(this, keyword)); } return(list); }
private static void GetTypeCompletions(SemanticModel semanticModel, SourceLocation position, CompletionContext context) { var symbols = semanticModel.LookupSymbols(position).OfType <TypeSymbol>(); CreateSymbolCompletions(symbols, context); }
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)); }
private static void GetMemberCompletions(SemanticModel semanticModel, FieldAccessExpressionSyntax propertyAccessExpression, CompletionContext context) { var targetType = semanticModel.GetExpressionType(propertyAccessExpression.Expression); if (targetType != null && !targetType.IsUnknown() && !targetType.IsError()) { GetTypeCompletions(targetType, context); } }
private static async Task <ImmutableArray <CompletionItem> > GetSnippetsForDocumentAsync( Document document, CompletionContext completionContext, CancellationToken cancellationToken) { var position = completionContext.Position; var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var syntaxFacts = document.GetRequiredLanguageService <ISyntaxFactsService>(); var semanticFacts = document.GetRequiredLanguageService <ISemanticFactsService>(); var root = syntaxTree.GetRoot(cancellationToken); var leftToken = root.FindTokenOnLeftOfPosition(position, includeDirectives: true); var targetToken = leftToken.GetPreviousTokenIfTouchingWord(position); if (syntaxFacts.IsInNonUserCode(syntaxTree, position, cancellationToken) || syntaxTree.IsRightOfDotOrArrowOrColonColon(position, targetToken, cancellationToken) || syntaxFacts.GetContainingTypeDeclaration(root, position) is EnumDeclarationSyntax || syntaxTree.IsPossibleTupleContext(leftToken, position)) { return(ImmutableArray <CompletionItem> .Empty); } var context = await completionContext.GetSyntaxContextWithExistingSpeculativeModelAsync(document, cancellationToken).ConfigureAwait(false); var semanticModel = context.SemanticModel; if (context.IsInTaskLikeTypeContext) { return(ImmutableArray <CompletionItem> .Empty); } if (syntaxFacts.IsPreProcessorDirectiveContext(syntaxTree, position, cancellationToken)) { var directive = leftToken.GetAncestor <DirectiveTriviaSyntax>(); Contract.ThrowIfNull(directive); 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(GetSnippetCompletionItems( document.Project.Solution.Workspace, semanticModel, isPreProcessorContext: true)); } } else { if (semanticFacts.IsGlobalStatementContext(semanticModel, position, cancellationToken) || semanticFacts.IsExpressionContext(semanticModel, position, cancellationToken) || semanticFacts.IsStatementContext(semanticModel, position, cancellationToken) || semanticFacts.IsTypeContext(semanticModel, position, cancellationToken) || semanticFacts.IsTypeDeclarationContext(semanticModel, position, cancellationToken) || semanticFacts.IsNamespaceContext(semanticModel, position, cancellationToken) || semanticFacts.IsNamespaceDeclarationNameContext(semanticModel, position, cancellationToken) || semanticFacts.IsMemberDeclarationContext(semanticModel, position, cancellationToken) || semanticFacts.IsLabelContext(semanticModel, position, cancellationToken)) { return(GetSnippetCompletionItems( document.Project.Solution.Workspace, semanticModel, isPreProcessorContext: false)); } } return(ImmutableArray <CompletionItem> .Empty); }
static void AddItems(CompletionItem item, bool isPublic, bool isInternalsVisible, CompletionContext completionContext, HashSet <string> namespacesInScope, TelemetryCounter counter) { if (isPublic || isInternalsVisible) { var containingNamespace = TypeImportCompletionItem.GetContainingNamespace(item); if (!namespacesInScope.Contains(containingNamespace)) { // We can return cached item directly, item's span will be fixed by completion service. // On the other hand, because of this (i.e. mutating the span of cached item for each run), // the provider can not be used as a service by components that might be run in parallel // with completion, which would be a race. completionContext.AddItem(item); counter.ItemsCount++;; } } }
public CompletionList Completion(TextDocumentIdentifier textDocument, Position position, CompletionContext context) { var doc = Session.DocumentStates[textDocument.Uri]; doc.AnalyzeAsync(); return (Session.Project.GetCompletionList(doc, position, context)); //position, Session.PageInfoStore)); }
/// <summary> /// The decision for whether to provide preselected items can be contextual, e.g. based on trigger character and syntax location /// </summary> protected virtual Task <bool> ShouldProvidePreselectedItemsAsync(CompletionContext completionContext, SyntaxContext syntaxContext, Document document, int position, Lazy <ImmutableArray <ITypeSymbol> > inferredTypes, OptionSet options) => SpecializedTasks.True;
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)); }
public override async Task ProvideCompletionsAsync(CompletionContext 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; } // Consider refining this logic to mandate completion with an argument name, if preceded by an out-of-position name // See https://github.com/dotnet/roslyn/issues/20657 var languageVersion = ((CSharpParseOptions)document.Project.ParseOptions).LanguageVersion; if (languageVersion < LanguageVersion.CSharp7_2 && token.IsMandatoryNamedParameterPosition()) { context.IsExclusive = true; } var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); 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(SymbolCompletionItem.CreateWithSymbolId( displayText: escapedName + ColonString, symbols: ImmutableArray.Create(parameter), rules: s_rules.WithMatchPriority(SymbolMatchPriority.PreferNamedArgument), contextPosition: token.SpanStart, filterText: escapedName)); } }
public override Task ProvideCompletionsAsync(CompletionContext context) => Task.CompletedTask;
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 abstract bool ShouldProvideCompletion(CompletionContext completionContext, SyntaxContext syntaxContext);
private static void GetTypeCompletions(TypeSymbol targetType, CompletionContext context) { CreateSymbolCompletions(targetType.Members, context); }
public virtual void Complete(CompletionContext context) { context.Editor.Document.Replace(context.StartOffset, context.Length, this.Text); context.EndOffset = context.StartOffset + this.Text.Length; }
public override async Task ProvideCompletionsAsync(CompletionContext completionContext) { try { var position = completionContext.Position; var document = completionContext.Document; var cancellationToken = completionContext.CancellationToken; var semanticModel = await document.ReuseExistingSpeculativeModelAsync(position, cancellationToken).ConfigureAwait(false); if (!completionContext.CompletionOptions.ShowNameSuggestions) { return; } var context = CSharpSyntaxContext.CreateContext(document, semanticModel, position, cancellationToken); if (context.IsInNonUserCode) { return; } var nameInfo = await NameDeclarationInfo.GetDeclarationInfoAsync(document, position, cancellationToken).ConfigureAwait(false); using var _ = ArrayBuilder <(string name, SymbolKind kind)> .GetInstance(out var result); // Suggest names from existing overloads. if (nameInfo.PossibleSymbolKinds.Any(k => k.SymbolKind == SymbolKind.Parameter)) { var(_, partialSemanticModel) = await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (partialSemanticModel is not null) { AddNamesFromExistingOverloads(context, partialSemanticModel, result, cancellationToken); } } var baseNames = GetBaseNames(semanticModel, nameInfo); if (baseNames != default) { await GetRecommendedNamesAsync(baseNames, nameInfo, context, document, result, cancellationToken).ConfigureAwait(false); } var recommendedNames = result.ToImmutable(); if (recommendedNames.IsEmpty) { return; } var sortValue = 0; foreach (var(name, kind) in recommendedNames) { // We've produced items in the desired order, add a sort text to each item to prevent alphabetization completionContext.AddItem(CreateCompletionItem(name, GetGlyph(kind, nameInfo.DeclaredAccessibility), sortValue.ToString("D8"))); sortValue++; } completionContext.SuggestionModeItem = CommonCompletionItem.Create( CSharpFeaturesResources.Name, displayTextSuffix: "", CompletionItemRules.Default); } catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General)) { // nop } }
private static void CreateSymbolCompletions(IEnumerable <Symbol> symbols, CompletionContext context) { context.AddItems(symbols .GroupBy(s => s.Name) .Select(g => CreateSymbolCompletionGroup(g.Key, g.ToImmutableArray()))); }
public override async Task ProvideCompletionsAsync(CompletionContext 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); foreach (var member in members) { var displayText = member.ToMinimalDisplayString(semanticModel, namePosition, s_signatureDisplayFormat); var insertionText = displayText; context.AddItem(SymbolCompletionItem.Create( displayText, insertionText: insertionText, span: context.DefaultItemSpan, symbol: member, contextPosition: position, descriptionPosition: position, rules: CompletionItemRules.Default)); } }
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 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(Task.FromResult(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(Task.FromResult(CreateCompletionData(engine, semanticModel, position, enclosingSymbol, token, false, cancellationToken))); } return(Task.FromResult(Enumerable.Empty <CompletionData> ())); } return(Task.FromResult(CreateCompletionData(engine, semanticModel, position, enclosingSymbol, token, true, cancellationToken))); }