/// <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]);
}
/// <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));
}
/// <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();
}
}
/// <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));
}