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 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)); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var semanticModel = ctx.SemanticModel; var result = new List <CompletionData> (); if (info.TriggerCharacter == ' ') { var newExpression = ObjectCreationContextHandler.GetObjectCreationNewExpression(ctx.SyntaxTree, completionContext.Position, cancellationToken); if (newExpression == null && info.CompletionTriggerReason == CompletionTriggerReason.CharTyped && !ctx.LeftToken.IsKind(SyntaxKind.EqualsToken) && !ctx.LeftToken.IsKind(SyntaxKind.EqualsEqualsToken)) { return(Enumerable.Empty <CompletionData> ()); } completionResult.AutoCompleteEmptyMatch = false; } var parent = ctx.TargetToken.Parent; bool isInAttribute = ctx.CSharpSyntaxContext.IsAttributeNameContext; bool isInBaseList = parent != null && parent.IsKind(SyntaxKind.BaseList); bool isInUsingDirective = parent != null && parent.Parent != null && parent.Parent.IsKind(SyntaxKind.UsingDirective) && !parent.IsKind(SyntaxKind.QualifiedName); var isInQuery = ctx.CSharpSyntaxContext.IsInQuery; var completionDataLookup = new Dictionary <Tuple <string, SymbolKind>, ISymbolCompletionData> (); bool isInCatchTypeExpression = parent.IsKind(SyntaxKind.CatchDeclaration) || parent.IsKind(SyntaxKind.QualifiedName) && parent != null && parent.Parent.IsKind(SyntaxKind.CatchDeclaration); Action <ISymbolCompletionData> addData = d => { var key = Tuple.Create(d.DisplayText, d.Symbol.Kind); ISymbolCompletionData data; if (completionDataLookup.TryGetValue(key, out data)) { data.AddOverload(d); return; } completionDataLookup.Add(key, d); result.Add(d); }; var completionCategoryLookup = new Dictionary <string, CompletionCategory> (); foreach (var symbol in Recommender.GetRecommendedSymbolsAtPosition(semanticModel, completionContext.Position, engine.Workspace, null, cancellationToken)) { if (symbol.Kind == SymbolKind.NamedType) { if (isInAttribute) { var type = (ITypeSymbol)symbol; if (type.IsAttribute()) { var v = type.Name.Substring(0, type.Name.Length - "Attribute".Length); var needsEscaping = SyntaxFacts.GetKeywordKind(v) != SyntaxKind.None; needsEscaping = needsEscaping || (isInQuery && SyntaxFacts.IsQueryContextualKeyword(SyntaxFacts.GetContextualKeywordKind(v))); if (!needsEscaping) { addData(engine.Factory.CreateSymbolCompletionData(this, symbol, v)); continue; } } } if (isInBaseList) { var type = (ITypeSymbol)symbol; if (type.IsSealed || type.IsStatic) { continue; } } if (isInCatchTypeExpression) { var type = (ITypeSymbol)symbol; if (!IsException(type)) { continue; } } } if (isInUsingDirective && symbol.Kind != SymbolKind.Namespace) { continue; } var newData = engine.Factory.CreateSymbolCompletionData(this, symbol, symbol.Name.EscapeIdentifier(isInQuery)); var categorySymbol = (ISymbol)symbol.ContainingType ?? symbol.ContainingNamespace; if (categorySymbol != null) { CompletionCategory category; var key = categorySymbol.ToDisplayString(); if (!completionCategoryLookup.TryGetValue(key, out category)) { completionCategoryLookup [key] = category = engine.Factory.CreateCompletionDataCategory(categorySymbol); } newData.CompletionCategory = category; } addData(newData); } return(result); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult result, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var list = new List <CompletionData> (); var newExpression = GetObjectCreationNewExpression(ctx.SyntaxTree, completionContext.Position, cancellationToken); if (newExpression == null) { if (ctx.SyntaxTree.IsInNonUserCode(completionContext.Position, cancellationToken) || ctx.SyntaxTree.IsPreProcessorDirectiveContext(completionContext.Position, cancellationToken)) { return(Enumerable.Empty <CompletionData> ()); } // if (!nkr.IsValid (completionContext.Position, ctx.CSharpSyntaxContext, cancellationToken)) // return Enumerable.Empty<ICompletionData> (); var tokenOnLeftOfPosition = ctx.SyntaxTree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken); if (!tokenOnLeftOfPosition.IsKind(SyntaxKind.EqualsToken) && !tokenOnLeftOfPosition.Parent.IsKind(SyntaxKind.EqualsValueClause)) { return(Enumerable.Empty <CompletionData> ()); } foreach (var inferredType in SyntaxContext.InferenceService.InferTypes(ctx.CSharpSyntaxContext.SemanticModel, completionContext.Position, cancellationToken)) { if (inferredType.IsEnumType() || inferredType.IsInterfaceType() || inferredType.IsAbstract) { continue; } foreach (var symbol in await GetPreselectedSymbolsWorker(ctx.CSharpSyntaxContext, inferredType, completionContext.Position - 1, cancellationToken)) { var symbolCompletionData = engine.Factory.CreateObjectCreation(this, inferredType, symbol, completionContext.Position, false); list.Add(symbolCompletionData); } } return(list); } var type = SyntaxContext.InferenceService.InferType(ctx.CSharpSyntaxContext.SemanticModel, newExpression, objectAsDefault: false, cancellationToken: cancellationToken); foreach (var symbol in await GetPreselectedSymbolsWorker(ctx.CSharpSyntaxContext, type, completionContext.Position, cancellationToken)) { var symbolCompletionData = engine.Factory.CreateObjectCreation(this, type, symbol, newExpression.SpanStart, true); list.Add(symbolCompletionData); if (string.IsNullOrEmpty(result.DefaultCompletionString)) { result.DefaultCompletionString = symbolCompletionData.DisplayText; } } foreach (var keyword in primitiveTypesKeywords) { list.Add(engine.Factory.CreateGenericData(this, keyword, GenericDataType.Keyword)); } return(list); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { if (info.IsDebugger) { return(null); } if (info.CompletionTriggerReason == CompletionTriggerReason.BackspaceOrDeleteCommand) { return(null); } var document = completionContext.Document; var position = completionContext.Position; var tree = await document.GetCSharpSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); var token = tree.FindTokenOnLeftOfPosition(position, cancellationToken); var parentTrivia = token.GetAncestor <DocumentationCommentTriviaSyntax>(); if (parentTrivia == null) { return(null); } var items = new List <CompletionData>(); var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); var span = GetTextChangeSpan(text, position); var attachedToken = parentTrivia.ParentTrivia.Token; if (attachedToken.Kind() == SyntaxKind.None) { return(null); } var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(attachedToken.Parent, cancellationToken).ConfigureAwait(false); ISymbol declaredSymbol = null; var memberDeclaration = attachedToken.GetAncestor <MemberDeclarationSyntax>(); if (memberDeclaration != null) { declaredSymbol = semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken); } else { var typeDeclaration = attachedToken.GetAncestor <TypeDeclarationSyntax>(); if (typeDeclaration != null) { declaredSymbol = semanticModel.GetDeclaredSymbol(typeDeclaration, cancellationToken); } } if (declaredSymbol != null) { items.AddRange(GetTagsForSymbol(engine, declaredSymbol, span, parentTrivia, token)); } if (token.Parent.Kind() == SyntaxKind.XmlEmptyElement || token.Parent.Kind() == SyntaxKind.XmlText || (token.Parent.IsKind(SyntaxKind.XmlElementEndTag) && token.IsKind(SyntaxKind.GreaterThanToken)) || (token.Parent.IsKind(SyntaxKind.XmlName) && token.Parent.IsParentKind(SyntaxKind.XmlEmptyElement))) { if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement) { items.AddRange(GetNestedTags(engine, span)); } if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement && ((XmlElementSyntax)token.Parent.Parent).StartTag.Name.LocalName.ValueText == "list") { items.AddRange(GetListItems(engine, span)); } if (token.Parent.IsParentKind(SyntaxKind.XmlEmptyElement) & token.Parent.Parent.IsParentKind(SyntaxKind.XmlElement)) { var element = (XmlElementSyntax)token.Parent.Parent.Parent; if (element.StartTag.Name.LocalName.ValueText == "list") { items.AddRange(GetListItems(engine, span)); } } if (token.Parent.Parent.Kind() == SyntaxKind.XmlElement && ((XmlElementSyntax)token.Parent.Parent).StartTag.Name.LocalName.ValueText == "listheader") { items.AddRange(GetListHeaderItems(engine, span)); } if (token.Parent.Parent is DocumentationCommentTriviaSyntax) { items.AddRange(GetTopLevelSingleUseNames(engine, parentTrivia, span)); items.AddRange(GetTopLevelRepeatableItems(engine, span)); } } if (token.Parent.Kind() == SyntaxKind.XmlElementStartTag) { var startTag = (XmlElementStartTagSyntax)token.Parent; if (token == startTag.GreaterThanToken && startTag.Name.LocalName.ValueText == "list") { items.AddRange(GetListItems(engine, span)); } if (token == startTag.GreaterThanToken && startTag.Name.LocalName.ValueText == "listheader") { items.AddRange(GetListHeaderItems(engine, span)); } } items.AddRange(GetAlwaysVisibleItems(engine, span)); return(items); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var document = completionContext.Document; var position = completionContext.Position; var syntaxTree = ctx.SyntaxTree; if (syntaxTree.IsInNonUserCode(position, cancellationToken)) { return(null); } var token = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken); token = token.GetPreviousTokenIfTouchingWord(position); if (token.Kind() != SyntaxKind.OpenParenToken && token.Kind() != SyntaxKind.CommaToken) { return(null); } var attributeArgumentList = token.Parent as AttributeArgumentListSyntax; var attributeSyntax = token.Parent.Parent as AttributeSyntax; if (attributeSyntax == null || attributeArgumentList == null) { return(null); } // We actually want to collect two sets of named parameters to present the user. The // normal named parameters that come from the attribute constructors. These will be // presented like "foo:". And also the named parameters that come from the writable // fields/properties in the attribute. These will be presented like "bar =". var existingNamedParameters = GetExistingNamedParameters(attributeArgumentList, position); var workspace = document.Project.Solution.Workspace; var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(attributeSyntax, cancellationToken).ConfigureAwait(false); var nameColonItems = await GetNameColonItemsAsync(engine, workspace, semanticModel, position, token, attributeSyntax, existingNamedParameters, cancellationToken).ConfigureAwait(false); var nameEqualsItems = await GetNameEqualsItemsAsync(engine, workspace, semanticModel, position, token, attributeSyntax, existingNamedParameters, cancellationToken).ConfigureAwait(false); // If we're after a name= parameter, then we only want to show name= parameters. if (IsAfterNameEqualsArgument(token)) { return(nameEqualsItems); } return(nameColonItems.Concat(nameEqualsItems)); }
protected 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); }
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); }
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 workspace = document.Project.Solution.Workspace; var semanticModel = await document.GetSemanticModelForSpanAsync(new TextSpan (position, 0), cancellationToken).ConfigureAwait(false); var typeAndLocation = GetInitializedType(document, semanticModel, position, cancellationToken); if (typeAndLocation == null) { return(Enumerable.Empty <CompletionData> ()); } var initializedType = typeAndLocation.Item1 as INamedTypeSymbol; var initializerLocation = typeAndLocation.Item2; if (initializedType == null) { return(Enumerable.Empty <CompletionData> ()); } // 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) && !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()); // var text = await semanticModel.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false); // var changes = GetTextChangeSpan(text, position); var list = new List <CompletionData> (); // Return the members foreach (var member in uninitializedMembers) { list.Add(engine.Factory.CreateSymbolCompletionData(this, member)); } 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; if (ctx.CSharpSyntaxContext.IsInNonUserCode) { return(Enumerable.Empty <CompletionData> ()); } if (ctx.TargetToken.IsKind(SyntaxKind.OverrideKeyword)) { return(Enumerable.Empty <CompletionData> ()); } if (info.CompletionTriggerReason == CompletionTriggerReason.CharTyped && info.TriggerCharacter == ' ') { if (!ctx.CSharpSyntaxContext.IsEnumBaseListContext && !ctx.LeftToken.IsKind(SyntaxKind.EqualsToken) && !ctx.LeftToken.IsKind(SyntaxKind.EqualsEqualsToken)) { return(Enumerable.Empty <CompletionData> ()); } // completionResult.AutoCompleteEmptyMatch = false; } var result = new List <CompletionData> (); foreach (var r in recommender) { var recommended = r.RecommendKeywords(completionContext.Position, ctx.CSharpSyntaxContext, cancellationToken); if (recommended == null) { continue; } foreach (var kw in recommended) { result.Add(engine.Factory.CreateGenericData(this, kw.Keyword, GenericDataType.Keyword)); } } // if (ctx.IsPreProcessorKeywordContext) { // foreach (var kw in preprocessorKeywords) // result.Add(factory.CreateGenericData (this, kw, GenericDataType.PreprocessorKeyword)); // } // // if (parent.IsKind(SyntaxKind.TypeParameterConstraintClause)) { // result.Add(factory.CreateGenericData (this, "new()", GenericDataType.PreprocessorKeyword)); // } 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 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.OpenBracketToken && token.Kind() != SyntaxKind.CommaToken) { return(null); } var argumentList = token.Parent as BaseArgumentListSyntax; if (argumentList == null) { return(null); } var semanticModel = await document.GetCSharpSemanticModelForNodeAsync(argumentList, cancellationToken).ConfigureAwait(false); var parameterLists = GetParameterLists(semanticModel, position, argumentList.Parent, cancellationToken); if (parameterLists == null) { return(null); } 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); // var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false); return(unspecifiedParameters .Select(p => engine.Factory.CreateGenericData(this, p.Name + ":", GenericDataType.NamedParameter))); }
protected abstract Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult result, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken 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 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 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(Enumerable.Empty <CompletionData> ()); } if (SemanticHighlightingVisitor <int> .IsRegexMatchMethod(symbolInfo)) { if (((ArgumentListSyntax)argument.Parent).Arguments [1] != argument) { return(Enumerable.Empty <CompletionData> ()); } completionResult.AutoSelect = false; return(GetFormatCompletionData(engine, argument.Expression.ToString() [0] == '@')); } if (SemanticHighlightingVisitor <int> .IsRegexConstructor(symbolInfo)) { if (((ArgumentListSyntax)argument.Parent).Arguments [0] != argument) { return(Enumerable.Empty <CompletionData> ()); } completionResult.AutoSelect = false; return(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(items); } } } return(Enumerable.Empty <CompletionData> ()); }
void AddDelegateHandlers(List <CompletionData> completionList, SyntaxNode parent, SemanticModel semanticModel, CompletionEngine engine, CompletionResult result, ITypeSymbol delegateType, int position, string optDelegateName, CancellationToken cancellationToken) { var delegateMethod = delegateType.GetDelegateInvokeMethod(); result.PossibleDelegates.Add(delegateMethod); var thisLineIndent = ""; string EolMarker = "\n"; bool addSemicolon = true; bool addDefault = true; string delegateEndString = EolMarker + thisLineIndent + "}" + (addSemicolon ? ";" : ""); //bool containsDelegateData = completionList.Result.Any(d => d.DisplayText.StartsWith("delegate(")); CompletionData item; if (addDefault) { item = engine.Factory.CreateAnonymousMethod( this, "delegate", "Creates anonymous delegate.", "delegate {" + EolMarker + thisLineIndent, delegateEndString ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } //if (LanguageVersion.Major >= 5) item = engine.Factory.CreateAnonymousMethod( this, "async delegate", "Creates anonymous async delegate.", "async delegate {" + EolMarker + thisLineIndent, delegateEndString ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } } var sb = new StringBuilder("("); var sbWithoutTypes = new StringBuilder("("); for (int k = 0; k < delegateMethod.Parameters.Length; k++) { if (k > 0) { sb.Append(", "); sbWithoutTypes.Append(", "); } sb.Append(RoslynCompletionData.SafeMinimalDisplayString(delegateMethod.Parameters [k], semanticModel, position, overrideNameFormat)); sbWithoutTypes.Append(delegateMethod.Parameters [k].Name); } sb.Append(")"); sbWithoutTypes.Append(")"); var signature = sb.ToString() .Replace(", params ", ", ") .Replace("(params ", "("); if (completionList.All(data => data.DisplayText != signature)) { item = engine.Factory.CreateAnonymousMethod( this, signature + " =>", "Creates typed lambda expression.", signature + " => ", (addSemicolon ? ";" : "") ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } // if (LanguageVersion.Major >= 5) { item = engine.Factory.CreateAnonymousMethod( this, "async " + signature + " =>", "Creates typed async lambda expression.", "async " + signature + " => ", (addSemicolon ? ";" : "") ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } var signatureWithoutTypes = sbWithoutTypes.ToString(); if (!delegateMethod.Parameters.Any(p => p.RefKind != RefKind.None) && completionList.All(data => data.DisplayText != signatureWithoutTypes)) { item = engine.Factory.CreateAnonymousMethod( this, signatureWithoutTypes + " =>", "Creates typed lambda expression.", signatureWithoutTypes + " => ", (addSemicolon ? ";" : "") ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } //if (LanguageVersion.Major >= 5) { item = engine.Factory.CreateAnonymousMethod( this, "async " + signatureWithoutTypes + " =>", "Creates typed async lambda expression.", "async " + signatureWithoutTypes + " => ", (addSemicolon ? ";" : "") ); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } //} } } string varName = optDelegateName ?? "Handle" + delegateType.Name; var curType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol> (position, cancellationToken); var uniqueName = new UniqueNameGenerator(semanticModel).CreateUniqueMethodName(parent, varName); item = engine.Factory.CreateNewMethodDelegate(this, delegateType, uniqueName, curType); if (!completionList.Any(i => i.DisplayText == item.DisplayText)) { completionList.Add(item); } }
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>()); }
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)); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var document = completionContext.Document; var position = completionContext.Position; var tree = ctx.SyntaxTree; //DeclarationModifiers modifiers; SyntaxToken token; var semanticModel = ctx.SemanticModel; var enclosingSymbol = semanticModel.GetEnclosingSymbol(position, cancellationToken) as INamedTypeSymbol; // Only inside classes and structs if (enclosingSymbol == null || !(enclosingSymbol.TypeKind == TypeKind.Struct || enclosingSymbol.TypeKind == TypeKind.Class)) { return(Enumerable.Empty <CompletionData> ()); } if (!IsPartialCompletionContext(tree, position, cancellationToken /*, out modifiers*/, out token)) { if (enclosingSymbol != null && (token.IsKind(SyntaxKind.OpenBraceToken) || token.IsKind(SyntaxKind.CloseBraceToken) || token.IsKind(SyntaxKind.SemicolonToken))) { return(CreateCompletionData(engine, semanticModel, position, enclosingSymbol, token, false, cancellationToken)); } return(Enumerable.Empty <CompletionData> ()); } return(CreateCompletionData(engine, semanticModel, position, enclosingSymbol, token, true, cancellationToken)); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var position = completionContext.Position; var document = completionContext.Document; var span = new TextSpan(position, 0); var semanticModel = await document.GetCSharpSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false); var syntaxTree = semanticModel.SyntaxTree; // var ctx = await completionContext.GetSyntaxContextAsync (engine.Workspace, cancellationToken).ConfigureAwait (false); if (syntaxTree.IsInNonUserCode(position, cancellationToken) || syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken)) { return(Enumerable.Empty <CompletionData> ()); } if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken)) { return(Enumerable.Empty <CompletionData> ()); } var node = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken) .GetPreviousTokenIfTouchingWord(position) .Parent; if (node.Kind() == SyntaxKind.ExplicitInterfaceSpecifier) { return(await GetCompletionsOffOfExplicitInterfaceAsync( engine, document, semanticModel, position, ((ExplicitInterfaceSpecifierSyntax)node).Name, cancellationToken).ConfigureAwait(false)); } return(Enumerable.Empty <CompletionData> ()); }
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); }
protected async override Task <IEnumerable <CompletionData> > GetItemsWorkerAsync(CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken) { var model = ctx.SemanticModel; var tree = ctx.SyntaxTree; if (tree.IsInNonUserCode(completionContext.Position, cancellationToken)) { return(Enumerable.Empty <CompletionData> ()); } var token = tree.FindTokenOnLeftOfPosition(completionContext.Position, cancellationToken); if (token.IsMandatoryNamedParameterPosition()) { return(Enumerable.Empty <CompletionData> ()); } var result = new List <CompletionData> (); foreach (var _type in ctx.InferredTypes) { var type = _type; if (type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) { type = type.GetTypeArguments().FirstOrDefault(); if (type == null) { continue; } } if (type.TypeKind != TypeKind.Enum) { continue; } if (!type.IsEditorBrowsable()) { continue; } // Does type have any aliases? ISymbol alias = await type.FindApplicableAlias(completionContext.Position, model, cancellationToken).ConfigureAwait(false); if (string.IsNullOrEmpty(completionResult.DefaultCompletionString)) { completionResult.DefaultCompletionString = type.Name; } result.Add(engine.Factory.CreateSymbolCompletionData(this, type, RoslynCompletionData.SafeMinimalDisplayString(type, model, completionContext.Position, SymbolDisplayFormat.CSharpErrorMessageFormat))); foreach (IFieldSymbol field in type.GetMembers().OfType <IFieldSymbol>()) { if (field.DeclaredAccessibility == Accessibility.Public && (field.IsConst || field.IsStatic)) { result.Add(engine.Factory.CreateEnumMemberCompletionData(this, alias, field)); } } } return(result); }
protected 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); }
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> ()); }
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 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 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 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) { return(Task.FromResult(Enumerable.Empty <CompletionData> ())); } var list = new List <CompletionData> (); var within = model.GetEnclosingNamedTypeOrAssembly(position, cancellationToken); var addedSymbols = new HashSet <string> (); SyntaxNode ancestor = ma.Expression; while (ancestor != null) { // check parent if for direct type check var ifStmSyntax = ancestor as IfStatementSyntax; if (ifStmSyntax != null) { var condition = SkipParens(ifStmSyntax.Condition); if (condition != null && condition.IsKind(SyntaxKind.IsExpression)) { 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, model.GetTypeInfo(isExpr.Left).Type, within, list, addedSymbols, cancellationToken); } } } // skip if else ... if else if (ancestor.Parent is ElseClauseSyntax) { while (ancestor is IfStatementSyntax || ancestor is ElseClauseSyntax) { ancestor = ancestor.Parent; } continue; } goto loop; } // check parent block if an if is there that checks the type var blockSyntax = ancestor as BlockSyntax; if (blockSyntax != null) { foreach (var ifStmt in blockSyntax.Statements.OfType <IfStatementSyntax> ()) { if (ifStmt.Span.End >= ma.Span.Start) { break; } var condition = SkipParens(ifStmt.Condition); bool wasNegated = false; if (condition.IsKind(SyntaxKind.LogicalNotExpression)) { condition = SkipParens(((PrefixUnaryExpressionSyntax)condition).Operand); wasNegated = true; } if (condition == null || !condition.IsKind(SyntaxKind.IsExpression)) { goto loop; } var stmt = ifStmt.Statement; if (stmt is BlockSyntax) { stmt = ((BlockSyntax)stmt).Statements.LastOrDefault(); } if (!wasNegated || stmt == null || !stmt.IsKind(SyntaxKind.ReturnStatement) && !stmt.IsKind(SyntaxKind.ContinueStatement) && !stmt.IsKind(SyntaxKind.BreakStatement) && !stmt.IsKind(SyntaxKind.ThrowStatement)) { goto loop; } 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, model.GetTypeInfo(isExpr.Left).Type, within, list, addedSymbols, cancellationToken); } } } } var binOp = ancestor as BinaryExpressionSyntax; if (binOp != null && binOp.IsKind(SyntaxKind.LogicalAndExpression)) { if (SkipParens(binOp.Left).IsKind(SyntaxKind.IsExpression)) { var isExpr = (BinaryExpressionSyntax)SkipParens(binOp.Left); 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, model.GetTypeInfo(isExpr.Left).Type, within, list, addedSymbols, cancellationToken); } } } } loop : ancestor = ancestor.Parent; } return(Task.FromResult((IEnumerable <CompletionData>)list)); }