/// <summary>
/// Finds parameter name by parameter index and determines
/// if the parameter is a named argument.
/// </summary>
/// <param name="index">Parameter index</param>
/// <param name="namedParameter">If true, parameter is a named argument</param>
/// <returns></returns>
public string GetParameterName(int index, out bool namedParameter)
{
namedParameter = false;
if (index < 0 || index > Arguments.Count - 1)
{
return(string.Empty);
}
CommaSeparatedItem arg = Arguments[index];
if (arg is NamedArgument)
{
namedParameter = true;
return(((NamedArgument)arg).Name);
}
else if (arg is ExpressionArgument)
{
IExpression exp = ((ExpressionArgument)arg).ArgumentValue;
if (exp.Children.Count == 1 && exp.Children[0] is Variable)
{
return(((Variable)exp.Children[0]).Name);
}
}
return(string.Empty);
}
/// <summary>
/// Determines if position is in the argument name. Typically used to
/// a) suppress general intellisense when typing function arguments
/// in a function/ definition such as in 'x <- function(a|'
/// b) determine if completion list should contain argumet names
/// when user types inside function call.
/// </summary>
internal static bool IsInFunctionArgumentName <T>(AstRoot ast, int position) where T : class, IFunction
{
T funcDef = ast.GetNodeOfTypeFromPosition <T>(position);
if (funcDef == null || funcDef.OpenBrace == null || funcDef.Arguments == null)
{
return(false);
}
if (position < funcDef.OpenBrace.End || position >= funcDef.SignatureEnd)
{
return(false);
}
int start = funcDef.OpenBrace.End;
int end = funcDef.SignatureEnd;
if (funcDef.Arguments.Count == 0 && position >= start && position <= end)
{
return(true);
}
for (int i = 0; i < funcDef.Arguments.Count; i++)
{
CommaSeparatedItem csi = funcDef.Arguments[i];
NamedArgument na = csi as NamedArgument;
if (position < csi.Start)
{
break;
}
end = csi.End;
if (position >= start && position <= end)
{
if (na == null)
{
return(true);
}
if (position <= na.EqualsSign.Start)
{
return(true);
}
}
}
return(false);
}
