示例#1
0
        /// <summary>
        /// Similiar to <see cref="ListArg{T}.Equal"/> but without considering the order of the elements in the collection.
        /// </summary>
        public static T[] Equivalent <T> (this ListArg <IEnumerable <T> > arg, params T[] items)
        {
            var argManagerType = typeof(ListArg <>).Assembly.GetType("Rhino.Mocks.ArgManager", true);
            var message        = "equivalent to collection [" + string.Join(", ", items) + "]";
            var constraint     = new PredicateConstraintWithMessage <IEnumerable <T> > (c => c.SetEquals(items), message);

            PrivateInvoke.InvokeNonPublicStaticMethod(argManagerType, "AddInArgument", constraint);

            return(new T[0]);
        }
示例#2
0
        /// <summary>
        /// Similiar to <see cref="ListArg{T}.Equal"/> but without considering the order of the elements in the collection.
        /// </summary>
        public static T Equivalent <T> (this ListArg <T> arg, IEnumerable collection) where T : IEnumerable
        {
            var items      = collection.Cast <object>().ToArray();
            var type       = typeof(ListArg <>).Assembly.GetType("Rhino.Mocks.ArgManager", true);
            var message    = "equivalent to collection [" + string.Join(", ", (IEnumerable <object>)items) + "]";
            var constraint = new PredicateConstraintWithMessage <T> (c => c.Cast <object>().SetEquals(items), message);

            PrivateInvoke.InvokeNonPublicStaticMethod(type, "AddInArgument", constraint);
            return(default(T));
        }
示例#3
0
        /// <summary>
        /// Creates set of arguments for a function call based on the call expression
        /// and the function signature. The result contains expressions
        /// for arguments, but not actual values. <see cref="Evaluate"/> on how to
        /// get values for actual parameters.
        /// </summary>
        /// <param name="fn">Function type.</param>
        /// <param name="overloadIndex">Function overload to call.</param>
        /// <param name="instance">Type instance the function is bound to. For derived classes it is different from the declared type.</param>
        /// <param name="callExpr">Call expression that invokes the function.</param>
        /// <param name="module">Module that contains the call expression.</param>
        /// <param name="eval">Evaluator that can calculate values of arguments from their respective expressions.</param>
        public ArgumentSet(IPythonFunctionType fn, int overloadIndex, IPythonInstance instance, CallExpression callExpr, IPythonModule module, IExpressionEvaluator eval)
        {
            Eval            = eval;
            OverloadIndex   = overloadIndex;
            DeclaringModule = fn.DeclaringModule;

            var overload = fn.Overloads[overloadIndex];
            var fd       = overload.FunctionDefinition;

            if (fd == null || fn.IsSpecialized)
            {
                // Typically specialized function, like TypeVar() that does not actually have AST definition.
                // Make the arguments from the call expression. If argument does not have name,
                // try using name from the function definition based on the argument position.
                _arguments = new List <Argument>();
                for (var i = 0; i < callExpr.Args.Count; i++)
                {
                    var name = callExpr.Args[i].Name;
                    if (string.IsNullOrEmpty(name))
                    {
                        name = fd != null && i < fd.Parameters.Length ? fd.Parameters[i].Name : null;
                    }
                    name = name ?? $"arg{i}";
                    var parameter = fd != null && i < fd.Parameters.Length ? fd.Parameters[i] : null;
                    _arguments.Add(new Argument(name, ParameterKind.Normal, callExpr.Args[i].Expression, null, parameter));
                }
                return;
            }

            if (callExpr == null)
            {
                // Typically invoked by specialization code without call expression in the code.
                // Caller usually does not care about arguments.
                _evaluated = true;
                return;
            }
            var callLocation = callExpr.GetLocation(module);

            // https://www.python.org/dev/peps/pep-3102/#id5
            // For each formal parameter, there is a slot which will be used to contain
            // the value of the argument assigned to that parameter. Slots which have
            // had values assigned to them are marked as 'filled'.Slots which have
            // no value assigned to them yet are considered 'empty'.

            var slots = fd.Parameters.Select(p => new Argument(p, p)).ToArray();
            // Locate sequence argument, if any
            var sa = slots.Where(s => s.Kind == ParameterKind.List).ToArray();

            if (sa.Length > 1)
            {
                // Error should have been reported at the function definition location by the parser.
                return;
            }

            var da = slots.Where(s => s.Kind == ParameterKind.Dictionary).ToArray();

            if (da.Length > 1)
            {
                // Error should have been reported at the function definition location by the parser.
                return;
            }

            _listArgument = sa.Length == 1 && sa[0].Name.Length > 0 ? new ListArg(sa[0].Name, sa[0].ValueExpression, sa[0].Location) : null;
            _dictArgument = da.Length == 1 ? new DictArg(da[0].Name, da[0].ValueExpression, da[0].Location) : null;

            // Class methods
            var formalParamIndex = 0;

            if (fn.DeclaringType != null && fn.HasClassFirstArgument() && slots.Length > 0)
            {
                slots[0].Value = instance != null?instance.GetPythonType() : fn.DeclaringType;

                formalParamIndex++;
            }

            try {
                // Positional arguments
                var callParamIndex = 0;
                for (; callParamIndex < callExpr.Args.Count; callParamIndex++, formalParamIndex++)
                {
                    var arg = callExpr.Args[callParamIndex];

                    if (!string.IsNullOrEmpty(arg.Name) && !arg.Name.StartsWithOrdinal("**"))
                    {
                        // Keyword argument. Done with positionals.
                        break;
                    }

                    if (formalParamIndex >= fd.Parameters.Length)
                    {
                        // We ran out of formal parameters and yet haven't seen
                        // any sequence or dictionary ones. This looks like an error.
                        _errors.Add(new DiagnosticsEntry(Resources.Analysis_TooManyFunctionArguments, arg.GetLocation(module).Span,
                                                         ErrorCodes.TooManyFunctionArguments, Severity.Warning, DiagnosticSource.Analysis));
                        return;
                    }

                    var formalParam = fd.Parameters[formalParamIndex];
                    if (formalParam.IsList)
                    {
                        if (string.IsNullOrEmpty(formalParam.Name))
                        {
                            // If the next unfilled slot is a vararg slot, and it does not have a name, then it is an error.
                            _errors.Add(new DiagnosticsEntry(Resources.Analysis_TooManyPositionalArgumentBeforeStar, arg.GetLocation(module).Span,
                                                             ErrorCodes.TooManyPositionalArgumentsBeforeStar, Severity.Warning, DiagnosticSource.Analysis));
                            return;
                        }

                        // If the next unfilled slot is a vararg slot then all remaining
                        // non-keyword arguments are placed into the vararg slot.
                        if (_listArgument == null)
                        {
                            _errors.Add(new DiagnosticsEntry(Resources.Analysis_TooManyFunctionArguments, arg.GetLocation(module).Span,
                                                             ErrorCodes.TooManyFunctionArguments, Severity.Warning, DiagnosticSource.Analysis));
                            return;
                        }

                        for (; callParamIndex < callExpr.Args.Count; callParamIndex++)
                        {
                            arg = callExpr.Args[callParamIndex];
                            if (!string.IsNullOrEmpty(arg.Name))
                            {
                                // Keyword argument. Done here.
                                break;
                            }

                            _listArgument._Expressions.Add(arg.Expression);
                        }

                        break; // Sequence or dictionary parameter found. Done here.
                    }

                    if (formalParam.IsDictionary)
                    {
                        // Next slot is a dictionary slot, but we have positional arguments still.
                        _errors.Add(new DiagnosticsEntry(Resources.Analysis_TooManyPositionalArgumentBeforeStar, arg.GetLocation(module).Span,
                                                         ErrorCodes.TooManyPositionalArgumentsBeforeStar, Severity.Warning, DiagnosticSource.Analysis));
                        return;
                    }

                    // Regular parameter
                    slots[formalParamIndex].ValueExpression = arg.Expression;
                }

                // Keyword arguments
                for (; callParamIndex < callExpr.Args.Count; callParamIndex++)
                {
                    var arg = callExpr.Args[callParamIndex];

                    if (string.IsNullOrEmpty(arg.Name))
                    {
                        _errors.Add(new DiagnosticsEntry(Resources.Analysis_PositionalArgumentAfterKeyword, arg.GetLocation(module).Span,
                                                         ErrorCodes.PositionalArgumentAfterKeyword, Severity.Warning, DiagnosticSource.Analysis));
                        return;
                    }

                    var nvp = slots.FirstOrDefault(s => s.Name.EqualsOrdinal(arg.Name));
                    if (nvp == null)
                    {
                        // 'def f(a, b)' and then 'f(0, c=1)'. Per spec:
                        // if there is a 'keyword dictionary' argument, the argument is added
                        // to the dictionary using the keyword name as the dictionary key,
                        // unless there is already an entry with that key, in which case it is an error.
                        if (_dictArgument == null)
                        {
                            _errors.Add(new DiagnosticsEntry(Resources.Analysis_UnknownParameterName, arg.GetLocation(module).Span,
                                                             ErrorCodes.UnknownParameterName, Severity.Warning, DiagnosticSource.Analysis));
                            return;
                        }

                        if (_dictArgument.Arguments.ContainsKey(arg.Name))
                        {
                            _errors.Add(new DiagnosticsEntry(Resources.Analysis_ParameterAlreadySpecified.FormatUI(arg.Name), arg.GetLocation(module).Span,
                                                             ErrorCodes.ParameterAlreadySpecified, Severity.Warning, DiagnosticSource.Analysis));
                            return;
                        }

                        _dictArgument._Expressions[arg.Name] = arg.Expression;
                        continue;
                    }

                    if (nvp.ValueExpression != null || nvp.Value != null)
                    {
                        // Slot is already filled.
                        _errors.Add(new DiagnosticsEntry(Resources.Analysis_ParameterAlreadySpecified.FormatUI(arg.Name), arg.GetLocation(module).Span,
                                                         ErrorCodes.ParameterAlreadySpecified, Severity.Warning, DiagnosticSource.Analysis));
                        return;
                    }

                    // OK keyword parameter
                    nvp.ValueExpression = arg.Expression;
                }

                // We went through all positionals and keywords.
                // For each remaining empty slot: if there is a default value for that slot,
                // then fill the slot with the default value. If there is no default value,
                // then it is an error.
                foreach (var slot in slots.Where(s => s.Kind != ParameterKind.List && s.Kind != ParameterKind.Dictionary && s.Value == null))
                {
                    if (slot.ValueExpression == null)
                    {
                        var parameter = fd.Parameters.First(p => p.Name == slot.Name);
                        if (parameter.DefaultValue == null)
                        {
                            // TODO: parameter is not assigned and has no default value.
                            _errors.Add(new DiagnosticsEntry(Resources.Analysis_ParameterMissing.FormatUI(slot.Name), callLocation.Span,
                                                             ErrorCodes.ParameterMissing, Severity.Warning, DiagnosticSource.Analysis));
                        }
                        // Note that parameter default value expression is from the function definition AST
                        // while actual argument values are from the calling file AST.
                        slot.ValueExpression = parameter.DefaultValue;
                        slot.ValueIsDefault  = true;
                    }
                }
            } finally {
                // Optimistically return what we gathered, even if there are errors.
                _arguments = slots.Where(s => s.Kind != ParameterKind.List && s.Kind != ParameterKind.Dictionary).ToList();
            }
        }
示例#4
0
 /// <summary>
 /// Similiar to <see cref="ListArg{T}.Equal"/> but without considering the order of the elements in the collection.
 /// </summary>
 public static T Equivalent <T> (this ListArg <T> arg, params object[] items) where T : IEnumerable
 {
     return(Equivalent(arg, (IEnumerable)items));
 }