/// <summary>
/// Compares two assignment arguments.
/// </summary>
/// <param name="argument1">The first argument.</param>
/// <param name="argument2">The second argument.</param>
public static bool IsAssignmentArgumentEqual(IAssignmentArgument argument1, IAssignmentArgument argument2)
{
if (argument1 == null)
{
throw new ArgumentNullException(nameof(argument1));
}
if (argument2 == null)
{
throw new ArgumentNullException(nameof(argument2));
}
bool Result = true;
Result &= argument1.ParameterList.Count != argument2.ParameterList.Count;
for (int i = 0; i < argument1.ParameterList.Count && i < argument2.ParameterList.Count; i++)
{
IIdentifier Parameter1 = argument1.ParameterList[i];
IIdentifier Parameter2 = argument2.ParameterList[i];
Result &= Parameter1.ValidText.Item == Parameter2.ValidText.Item;
}
Result &= Expression.IsExpressionEqual((IExpression)argument1.Source, (IExpression)argument2.Source);
return(Result);
}
private static bool ValidateAssignmentStyle(IList <IArgument> argumentList, List <IExpressionType> mergedArgumentList, IErrorList errorList)
{
ISealableDictionary <string, IArgument> DuplicateNameTable = new SealableDictionary <string, IArgument>();
for (int i = 0; i < argumentList.Count; i++)
{
IAssignmentArgument Argument = argumentList[i] as IAssignmentArgument;
Debug.Assert(Argument != null);
IExpression Source = (IExpression)Argument.Source;
IList <IIdentifier> ParameterList = Argument.ParameterList;
if (ParameterList.Count > 1 && Argument.ResolvedResult.Item.Count == 1)
{
IExpressionType Item = Argument.ResolvedResult.Item.At(0);
for (int j = 0; j < ParameterList.Count; j++)
{
IExpressionType ItemJ = new ExpressionType(Item.ValueTypeName, Item.ValueType, ParameterList[j].ValidText.Item);
ItemJ.SetSource(Source, 0);
mergedArgumentList.Add(ItemJ);
}
}
else
{
for (int j = 0; j < Argument.ResolvedResult.Item.Count; j++)
{
IExpressionType Item = Argument.ResolvedResult.Item.At(j);
Item.SetName(ParameterList[j].ValidText.Item);
if (mergedArgumentList.Exists((IExpressionType other) => { return(Item.Name == other.Name); }))
{
if (!DuplicateNameTable.ContainsKey(Item.Name))
{
DuplicateNameTable.Add(Item.Name, Argument);
}
}
Item.SetSource(Source, j);
mergedArgumentList.Add(Item);
}
}
}
if (DuplicateNameTable.Count > 0)
{
foreach (KeyValuePair <string, IArgument> Entry in DuplicateNameTable)
{
errorList.AddError(new ErrorDuplicateName(Entry.Value, Entry.Key));
}
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpAssignmentArgument"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly argument from which the C# argument is created.</param>
protected CSharpAssignmentArgument(ICSharpContext context, IAssignmentArgument source)
: base(context, source)
{
IExpression ArgumentSource = (IExpression)source.Source;
SourceExpression = CSharpExpression.Create(context, ArgumentSource);
foreach (IIdentifier Item in source.ParameterList)
{
ParameterNameList.Add(Item.ValidText.Item);
}
}
/// <summary>
/// Compares two expressions.
/// </summary>
/// <param name="other">The other expression.</param>
protected bool IsExpressionEqual(IInitializedObjectExpression other)
{
Debug.Assert(other != null);
bool Result = true;
Result &= AssignmentList.Count == other.AssignmentList.Count;
for (int i = 0; i < AssignmentList.Count && i < other.AssignmentList.Count; i++)
{
IAssignmentArgument InitializationAssignment1 = AssignmentList[i];
IAssignmentArgument InitializationAssignment2 = other.AssignmentList[i];
Result &= AssignmentArgument.IsAssignmentArgumentEqual(InitializationAssignment1, InitializationAssignment2);
}
return(Result);
}
/// <summary>
/// Creates a new C# argument.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly argument from which the C# argument is created.</param>
public static ICSharpAssignmentArgument Create(ICSharpContext context, IAssignmentArgument source)
{
return(new CSharpAssignmentArgument(context, source));
}
