public IPostfixLookupItem CreateItem(PostfixTemplateContext context)
        {
            if (context.IsAutoCompletion)
            {
                foreach (var expressionContext in context.Expressions)
                {
                    var castExpression = CastExpressionNavigator.GetByOp(expressionContext.Expression);
                    if (castExpression == null)
                    {
                        continue;               // available in auto over cast expressions
                    }
                    var expression = ParenthesizedExpressionNavigator.GetByExpression(castExpression);
                    if (expression != null)
                    {
                        continue;           // not already parenthesized
                    }
                    return(new ParenthesesItem(expressionContext));
                }

                return(null);
            }

            var contexts = CommonUtils.FindExpressionWithValuesContexts(context);

            if (contexts.Length == 0)
            {
                return(null);
            }

            return(new ParenthesesItem(contexts));
        }
コード例 #2
0
        public PostfixTemplateInfo TryCreateInfo(CSharpPostfixTemplateContext context)
        {
            if (context.IsPreciseMode)
            {
                foreach (var expressionContext in context.Expressions)
                {
                    var castExpression = CastExpressionNavigator.GetByOp(expressionContext.Expression);
                    if (castExpression == null)
                    {
                        continue;               // available in auto over cast expressions
                    }
                    var expression = ParenthesizedExpressionNavigator.GetByExpression(castExpression);
                    if (expression != null)
                    {
                        continue;           // not already parenthesized
                    }
                    return(new PostfixTemplateInfo("par", expressionContext));
                }

                return(null);
            }

            var expressions = CSharpPostfixUtis.FindExpressionWithValuesContexts(context);

            if (expressions.Length != 0)
            {
                return(new PostfixTemplateInfo("par", expressions));
            }

            return(null);
        }
        protected override void Analyze(IInvocationExpression expression, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
        {
            var reference = (expression.InvokedExpression as IReferenceExpression)?.Reference;

            if (reference == null)
            {
                return;
            }

            var info = reference.Resolve();

            if (info.ResolveErrorType != ResolveErrorType.OK)
            {
                return;
            }

            var method = info.DeclaredElement as IMethod;

            if (method == null)
            {
                return;
            }

            if (!method.ShortName.Equals(ourKnownMethod))
            {
                return;
            }

            if (method.GetContainingType()?.GetClrName().Equals(KnownTypes.Object) != true)
            {
                return;
            }


            var parameters = method.Parameters;

            if (parameters.Count != 1)
            {
                return;
            }

            var scope = expression.GetContainingFunctionLikeDeclarationOrClosure().GetCodeBody().GetAnyTreeNode();

            if (scope == null)
            {
                return;
            }

            IEnumerable <ITreeNode> usages = null;
            ITreeNode storage = null;
            var       containingParenthesizedExpression = expression.GetContainingParenthesizedExpression();
            var       castExpression = CastExpressionNavigator.GetByOp(containingParenthesizedExpression);
            var       asExpression   = AsExpressionNavigator.GetByOperand(containingParenthesizedExpression);
            var       initializer    = ExpressionInitializerNavigator.GetByValue(castExpression ?? asExpression ?? containingParenthesizedExpression);
            var       declaration    = LocalVariableDeclarationNavigator.GetByInitial(initializer);


            var usageProvider = data.GetUsagesProvider();

            if (declaration != null)
            {
                usages  = usageProvider.GetUsages(declaration.DeclaredElement, scope).Where(t => t is IReferenceExpression);
                storage = declaration;
            }
            else
            {
                var assignment = AssignmentExpressionNavigator.GetBySource(castExpression ?? asExpression ?? containingParenthesizedExpression);
                var dest       = assignment?.Dest as IReferenceExpression;
                var destInfo   = dest?.Reference.Resolve();
                if (destInfo != null && destInfo.ResolveErrorType == ResolveErrorType.OK)
                {
                    usages  = usageProvider.GetUsages(destInfo.DeclaredElement.NotNull(), scope).Where(t => IsSameReferenceUsed(t, dest));
                    storage = dest;
                }
                else
                {
                    return;
                }
            }

            foreach (var usage in usages)
            {
                if (usage is IReferenceExpression referenceExpression)
                {
                    var fullReferenceExpression = ReferenceExpressionNavigator.GetTopByQualifierExpression(referenceExpression);
                    if (IsUsageSetTransformParent(fullReferenceExpression, out var stayInWorldCoords, out var transform))
                    {
                        if (!InSameBlock(fullReferenceExpression, storage))
                        {
                            return;
                        }
                        var finder             = new TransformParentRelatedReferenceFinder(referenceExpression);
                        var relatedExpressions = finder.GetRelatedExpressions(scope, expression).FirstOrDefault();
                        if (relatedExpressions == null || relatedExpressions.GetTreeStartOffset() >= fullReferenceExpression.GetTreeStartOffset())
                        {
                            consumer.AddHighlighting(new InstantiateWithoutParentWarning(fullReferenceExpression, expression, transform, stayInWorldCoords));
                        }
                        return;
                    }
                }
            }
        }