private static int?NameUsedForPositional(AnalyzedArguments arguments, ParameterMap argsToParameters)
{
// Was there a named argument used for a previously-supplied positional argument?
// If the map is trivial then clearly not.
if (argsToParameters.IsTrivial)
{
return(null);
}
// PERFORMANCE: This is an O(n-squared) algorithm, but n will typically be small. We could rewrite this
// PERFORMANCE: as a linear algorithm if we wanted to allocate more memory.
for (int argumentPosition = 0; argumentPosition < argsToParameters.Length; ++argumentPosition)
{
if (arguments.Name(argumentPosition) != null)
{
for (int i = 0; i < argumentPosition; ++i)
{
if (arguments.Name(i) == null)
{
if (argsToParameters[argumentPosition] == argsToParameters[i])
{
// Error; we've got a named argument that corresponds to
// a previously-given positional argument.
return(argumentPosition);
}
}
}
}
}
return(null);
}
private static int?CheckForDuplicateNamedArgument(AnalyzedArguments arguments)
{
if (arguments.Names.IsEmpty())
{
// No checks if there are no named arguments
return(null);
}
var alreadyDefined = PooledHashSet <string> .GetInstance();
for (int i = 0; i < arguments.Names.Count; ++i)
{
string name = arguments.Name(i);
if (name is null)
{
// Skip unnamed arguments
continue;
}
if (!alreadyDefined.Add(name))
{
alreadyDefined.Free();
return(i);
}
}
alreadyDefined.Free();
return(null);
}
private static int?CheckForBadNonTrailingNamedArgument(
AnalyzedArguments arguments,
ParameterMap argsToParameters,
ImmutableArray <ParameterSymbol> parameters
)
{
// Is there any named argument used out-of-position and followed by unnamed arguments?
// If the map is trivial then clearly not.
if (argsToParameters.IsTrivial)
{
return(null);
}
// Find the first named argument which is used out-of-position
int foundPosition = -1;
int length = arguments.Arguments.Count;
for (int i = 0; i < length; i++)
{
int parameter = argsToParameters[i];
if (parameter != -1 && parameter != i && arguments.Name(i) != null)
{
foundPosition = i;
break;
}
}
if (foundPosition != -1)
{
// Verify that all the following arguments are named
for (int i = foundPosition + 1; i < length; i++)
{
if (arguments.Name(i) == null)
{
return(foundPosition);
}
}
}
return(null);
}
private static int? NameUsedForPositional(AnalyzedArguments arguments, ParameterMap argsToParameters)
{
// Was there a named argument used for a previously-supplied positional argument?
// If the map is trivial then clearly not.
if (argsToParameters.IsTrivial)
{
return null;
}
// PERFORMANCE: This is an O(n-squared) algorithm, but n will typically be small. We could rewrite this
// PERFORMANCE: as a linear algorithm if we wanted to allocate more memory.
for (int argumentPosition = 0; argumentPosition < argsToParameters.Length; ++argumentPosition)
{
if (arguments.Name(argumentPosition) != null)
{
for (int i = 0; i < argumentPosition; ++i)
{
if (arguments.Name(i) == null)
{
if (argsToParameters[argumentPosition] == argsToParameters[i])
{
// Error; we've got a named argument that corresponds to
// a previously-given positional argument.
return argumentPosition;
}
}
}
}
}
return null;
}