Ejemplo n.º 1
0
        public async Task <ParameterHintingResult> GetParameterDataProviderAsync(Document document, SemanticModel semanticModel, int position, CancellationToken cancellationToken = default(CancellationToken))
        {
            var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

            var tokenLeftOfPosition = tree.FindTokenOnLeftOfPosition(position, cancellationToken);

            if (tokenLeftOfPosition.IsKind(SyntaxKind.LessThanToken))
            {
                var startToken = tokenLeftOfPosition.GetPreviousToken();
                return(HandleTypeParameterCase(semanticModel, startToken.Parent, cancellationToken));
            }

            var context      = SyntaxContext.Create(workspace, document, semanticModel, position, cancellationToken);
            var targetParent = context.TargetToken.Parent;
            var node         = targetParent.Parent;

            // case: identifier<arg1,|
            if (node == null)
            {
                if (context.LeftToken.Kind() == SyntaxKind.CommaToken)
                {
                    targetParent = context.LeftToken.GetPreviousToken().Parent;
                    node         = targetParent.Parent;
                    if (node.Kind() == SyntaxKind.LessThanExpression)
                    {
                        return(HandleTypeParameterCase(semanticModel, ((BinaryExpressionSyntax)node).Left, cancellationToken));
                    }
                }
                return(ParameterHintingResult.Empty);
            }
            if (node.IsKind(SyntaxKind.Argument))
            {
                node = node.Parent.Parent;
            }
            switch (node.Kind())
            {
            case SyntaxKind.Attribute:
                return(HandleAttribute(semanticModel, node, cancellationToken));

            case SyntaxKind.ThisConstructorInitializer:
            case SyntaxKind.BaseConstructorInitializer:
                return(HandleConstructorInitializer(semanticModel, node, cancellationToken));

            case SyntaxKind.ObjectCreationExpression:
                return(HandleObjectCreationExpression(semanticModel, node, cancellationToken));

            case SyntaxKind.InvocationExpression:
                return(HandleInvocationExpression(semanticModel, (InvocationExpressionSyntax)node, cancellationToken));

            case SyntaxKind.ElementAccessExpression:
                return(HandleElementAccessExpression(semanticModel, (ElementAccessExpressionSyntax)node, cancellationToken));
            }
            return(ParameterHintingResult.Empty);
        }
        public override async Task ProvideCompletionsAsync(CompletionContext context)
        {
            if (Options.EnableUnimportedSuggestions)
            {
                _symbolMapping = new Dictionary <string, ISymbol>();
                var syntaxContext = await SyntaxContext.Create(context.Document, context.Position, context.CancellationToken)
                                    .ConfigureAwait(false);

                var symbols = GetSymbols(syntaxContext);
                var completionItemsToAdd = symbols
                                           .Select(symbol => CreateCompletionItemForSymbol(symbol, syntaxContext))
                                           .ToList();

                context.AddItems(completionItemsToAdd);
            }
        }