Пример #1
0
            void CheckFormattingCall(InvocationExpression invocationExpression, AlInvocationResolveResult invocationResolveResult)
            {
                Expression         formatArgument;
                IList <Expression> formatArguments;
                // Only check parameters that are of type object: String means it is neccessary, others
                // means that there is another problem (ie no matching overload of the method).
                Func <IParameter, Expression, bool> predicate = (parameter, argument) => {
                    var type = parameter.Type;
                    if (type is TypeWithElementType && parameter.IsParams)
                    {
                        type = ((TypeWithElementType)type).ElementType;
                    }
                    var typeDefinition = type.GetDefinition();
                    if (typeDefinition == null)
                    {
                        return(false);
                    }
                    return(typeDefinition.IsKnownType(KnownTypeCode.Object));
                };

                if (FormatStringHelper.TryGetFormattingParameters(invocationResolveResult, invocationExpression,
                                                                  out formatArgument, out formatArguments, predicate))
                {
                    foreach (var argument in formatArguments)
                    {
                        CheckExpressionInAutoCallContext(argument);
                    }
                }
            }
Пример #2
0
        AstNode ToStaticMethodInvocation(InvocationExpression invocation, MemberReferenceExpression memberReference,
                                         AlInvocationResolveResult invocationRR)
        {
            var newArgumentList = invocation.Arguments.Select(arg => arg.Clone()).ToList();

            newArgumentList.Insert(0, memberReference.Target.Clone());
            var newTarget = memberReference.Clone() as MemberReferenceExpression;

            newTarget.Target = new IdentifierExpression(invocationRR.Member.DeclaringType.Name);
            return(new InvocationExpression(newTarget, newArgumentList));
        }