/// <summary>
/// Checks that a result of a list of overloads conform to a base type.
/// </summary>
/// <param name="overloadList">The list of overloads.</param>
/// <param name="index">Index of the result in the possible results.</param>
/// <param name="baseType">The base type.</param>
/// <param name="location">The location where to report errors.</param>
/// <param name="errorList">The list of errors found.</param>
public static bool JoinedResultCheck(IList <IQueryOverloadType> overloadList, int index, ICompiledType baseType, ISource location, IErrorList errorList)
{
bool Success = true;
IList <IParameter> SameIndexList = new List <IParameter>();
foreach (IQueryOverloadType Overload in overloadList)
{
ISealableList <IParameter> ResultTable = Overload.ResultTable;
if (index < ResultTable.Count)
{
SameIndexList.Add(ResultTable[index]);
}
}
for (int i = 0; i < SameIndexList.Count; i++)
{
IParameter CurrentParameter = SameIndexList[i];
ICompiledType CurrentParameterType = CurrentParameter.ResolvedParameter.ResolvedEffectiveType.Item;
if (!ObjectType.TypeConformToBase(CurrentParameterType, baseType, isConversionAllowed: false))
{
errorList.AddError(new ErrorNonConformingType(location));
Success = false;
}
}
return(Success);
}
private static bool DisjoinedParameterCheck(IList <ICommandOverloadType> overloadList, int index, IErrorList errorList)
{
IList <IParameter> SameIndexList = new List <IParameter>();
foreach (ICommandOverloadType Overload in overloadList)
{
ISealableList <IParameter> ParameterTable = Overload.ParameterTable;
if (index < ParameterTable.Count)
{
SameIndexList.Add(ParameterTable[index]);
}
}
bool Success = true;
for (int i = 0; i < SameIndexList.Count && Success; i++)
{
IParameter Parameter1 = SameIndexList[i];
ICompiledType ParameterType1 = Parameter1.ResolvedParameter.ResolvedEffectiveType.Item;
for (int j = i + 1; j < SameIndexList.Count && Success; j++)
{
IParameter Parameter2 = SameIndexList[j];
ICompiledType ParameterType2 = Parameter2.ResolvedParameter.ResolvedEffectiveType.Item;
Success &= DisjoinedParameterCheck(Parameter1, Parameter2, errorList);
Success &= DisjoinedParameterCheck(Parameter2, Parameter1, errorList);
}
}
return(Success);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IIndexerType node, object data)
{
IClassType BaseType = ((Tuple <IClassType, ISealableList <IParameter> >)data).Item1;
ISealableList <IParameter> ParameterTable = ((Tuple <IClassType, ISealableList <IParameter> >)data).Item2;
IClass EmbeddingClass = node.EmbeddingClass;
IObjectType BaseTypeItem = (IObjectType)node.BaseType;
IObjectType EntityTypeItem = (IObjectType)node.EntityType;
Debug.Assert(node.ParameterTable.Count == 0);
node.ParameterTable.AddRange(ParameterTable);
node.ParameterTable.Seal();
ITypeName BaseTypeName = BaseTypeItem.ResolvedTypeName.Item;
ITypeName EntityTypeName = EntityTypeItem.ResolvedTypeName.Item;
ICompiledType EntityType = EntityTypeItem.ResolvedType.Item;
#if COVERAGE
string TypeString = node.ToString();
Debug.Assert(!node.IsReference);
Debug.Assert(node.IsValue);
#endif
IndexerType.ResolveType(EmbeddingClass.TypeTable, BaseTypeName, BaseType, EntityTypeName, EntityType, node.IndexerKind, node.IndexParameterList, node.ParameterEnd, node.GetRequireList, node.GetEnsureList, node.GetExceptionIdentifierList, node.SetRequireList, node.SetEnsureList, node.SetExceptionIdentifierList, out ITypeName ResolvedTypeName, out ICompiledType ResolvedType);
node.ResolvedTypeName.Item = ResolvedTypeName;
node.ResolvedType.Item = ResolvedType;
}
private static void GetCommonResultType(IList <IQueryOverloadType> overloadList, int index, out ITypeName resultTypeName, out ICompiledType resultType)
{
IList <IParameter> SameIndexList = new List <IParameter>();
foreach (IQueryOverloadType Overload in overloadList)
{
ISealableList <IParameter> ResultTable = Overload.ResultTable;
if (index < ResultTable.Count)
{
SameIndexList.Add(ResultTable[index]);
}
}
IParameter SelectedParameter = SameIndexList[0];
ITypeName SelectedParameterTypeName = SelectedParameter.ResolvedParameter.ResolvedEffectiveTypeName.Item;
ICompiledType SelectedParameterType = SelectedParameter.ResolvedParameter.ResolvedEffectiveType.Item;
for (int i = 1; i < SameIndexList.Count; i++)
{
IParameter CurrentParameter = SameIndexList[i];
ITypeName CurrentParameterTypeName = CurrentParameter.ResolvedParameter.ResolvedEffectiveTypeName.Item;
ICompiledType CurrentParameterType = CurrentParameter.ResolvedParameter.ResolvedEffectiveType.Item;
if (ObjectType.TypeConformToBase(SelectedParameterType, CurrentParameterType, isConversionAllowed: false))
{
SelectedParameter = CurrentParameter;
SelectedParameterTypeName = CurrentParameterTypeName;
SelectedParameterType = CurrentParameterType;
}
}
resultTypeName = SelectedParameterTypeName;
resultType = SelectedParameterType;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(ICommandOverload node, object data)
{
IClass EmbeddingClass = node.EmbeddingClass;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = ((Tuple <ISealableDictionary <string, IScopeAttributeFeature>, ISealableList <IParameter> >)data).Item1;
ISealableList <IParameter> ParameterTable = ((Tuple <ISealableDictionary <string, IScopeAttributeFeature>, ISealableList <IParameter> >)data).Item2;
node.ParameterTable.AddRange(ParameterTable);
node.ParameterTable.Seal();
IBody CommandBody = (IBody)node.CommandBody;
ICommandOverloadType AssociatedType = new CommandOverloadType(node.ParameterList, BaseNode.ParameterEndStatus.Closed, CommandBody.RequireList, CommandBody.EnsureList, CommandBody.ExceptionIdentifierList);
AssociatedType.ParameterTable.AddRange(ParameterTable);
AssociatedType.ParameterTable.Seal();
node.ResolvedAssociatedType.Item = AssociatedType;
node.LocalScope.Merge(CheckedScope);
node.LocalScope.Seal();
node.FullScope.Merge(node.LocalScope);
ScopeHolder.RecursiveAdd(node.FullScope, node.InnerScopes);
EmbeddingClass.BodyList.Add((IBody)node.CommandBody);
EmbeddingClass.CommandOverloadList.Add(node);
}
private static IList <ICompiledType> GetTypesConvertibleTo(IClassType type)
{
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = type.FeatureTable;
ISealableDictionary <IFeatureName, IFunctionFeature> ConversionToTable = type.BaseClass.ConversionToTable;
IList <ICompiledType> Result = new List <ICompiledType>();
foreach (KeyValuePair <IFeatureName, IFunctionFeature> Entry in ConversionToTable)
{
IFunctionFeature Feature = Entry.Value;
foreach (IQueryOverload Overload in Feature.OverloadList)
{
ISealableList <IParameter> ParameterTable = Overload.ParameterTable;
Debug.Assert(ParameterTable.IsSealed);
Debug.Assert(ParameterTable.Count == 0);
ISealableList <IParameter> ResultTable = Overload.ResultTable;
Debug.Assert(ResultTable.IsSealed);
Debug.Assert(ResultTable.Count == 1);
IParameter OverloadResult = ResultTable[0];
Debug.Assert(OverloadResult.ResolvedParameter.ResolvedEffectiveType.IsAssigned);
ICompiledType OverloadResultType = OverloadResult.ResolvedParameter.ResolvedEffectiveType.Item;
Result.Add(OverloadResultType);
}
}
return(Result);
}
/// <summary>
/// Checks if a node source is ready.
/// </summary>
/// <param name="node">The node for which the value is checked.</param>
/// <param name="data">Optional data returned to the caller.</param>
public override bool IsReady(TSource node, out object data)
{
IList ItemList = GetSourceObject(node, out bool IsInterrupted);
IList <ISealableList <TValue> > ReadyValueList = new List <ISealableList <TValue> >();
for (int i = 0; i < ItemList.Count && !IsInterrupted; i++)
{
TItem Item = (TItem)ItemList[i];
ISealableList <TValue> Value = ItemProperty.GetValue(Item) as ISealableList <TValue>;
Debug.Assert(Value != null);
if (Value.IsSealed)
{
ReadyValueList.Add(Value);
}
else
{
IsInterrupted = true;
}
}
if (IsInterrupted)
{
data = null;
return(false);
}
else
{
data = ReadyValueList;
return(true);
}
}
private static bool PositionalArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, IErrorList errorList, ISource source, out int selectedIndex)
{
ISealableList <IParameter> SelectedOverload = null;
selectedIndex = -1;
int MaximumAllowedArgumentCount = -1;
for (int i = 0; i < parameterTableList.Count; i++)
{
PositionalArgumentMatching(parameterTableList, arguments, i, ref MaximumAllowedArgumentCount, ref SelectedOverload, ref selectedIndex);
}
if (MaximumAllowedArgumentCount >= 0 && MaximumAllowedArgumentCount < arguments.Count)
{
errorList.AddError(new ErrorTooManyArguments(source, arguments.Count, MaximumAllowedArgumentCount));
return(false);
}
if (SelectedOverload == null)
{
errorList.AddError(new ErrorInvalidExpression(source));
return(false);
}
Debug.Assert(SelectedOverload.Count >= arguments.Count);
return(true);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IInitializedObjectExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item4;
ITypeName InitializedObjectTypeName = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item5;
IClassType InitializedObjectType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item6;
ISealableDictionary <string, ICompiledFeature> AssignedFeatureTable = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item7;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.ResolvedClassTypeName.Item = InitializedObjectTypeName;
node.ResolvedClassType.Item = InitializedObjectType;
Debug.Assert(node.AssignedFeatureTable.Count == 0);
node.AssignedFeatureTable.Merge(AssignedFeatureTable);
node.AssignedFeatureTable.Seal();
IClass BaseClass = InitializedObjectType.BaseClass;
BaseClass.InitializedObjectList.Add(node);
}
/// <summary>
/// True if the destination value has been set;
/// </summary>
/// <param name="node">The node for which the value is to be checked.</param>
public override bool IsSet(TSource node)
{
ISealableList <TItem> ListValue = GetDestinationObject(node);
Debug.Assert(ListValue == GetDestinationObject((ISource)node));
return(ListValue.IsSealed);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(ICommandOverloadType node, object data)
{
IClass EmbeddingClass = node.EmbeddingClass;
ISealableList <IParameter> ParameterTable = (ISealableList <IParameter>)data;
Debug.Assert(node.ParameterTable.Count == 0);
node.ParameterTable.AddRange(ParameterTable);
node.ParameterTable.Seal();
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IKeywordEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item4;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IAgentExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IAssertionTagExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item4;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IInitializedObjectExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item4;
ITypeName InitializedObjectTypeName = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item5;
IClassType InitializedObjectType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item6;
ISealableDictionary <string, ICompiledFeature> AssignedFeatureTable = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item7;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IUnaryOperatorExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item4;
IFunctionFeature SelectedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item5;
IQueryOverload SelectedOverload = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item6;
IQueryOverloadType SelectedOverloadType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item7;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(INewExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IClassConstantExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item4;
Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> AdditionalData = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item5;
IConstantFeature ResolvedFinalFeature = AdditionalData.Item1;
IDiscrete ResolvedFinalDiscrete = AdditionalData.Item2;
ITypeName ResolvedClassTypeName = AdditionalData.Item3;
IClassType ResolvedClassType = AdditionalData.Item4;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Checks if a node source is ready.
/// </summary>
/// <param name="node">The node for which the value is checked.</param>
/// <param name="data">Optional data returned to the caller.</param>
public override bool IsReady(TSource node, out object data)
{
data = null;
bool Result = false;
ISealableList <TValue> Value = GetSourceObject(node, out bool IsInterrupted) as ISealableList <TValue>;
Debug.Assert(Value != null || IsInterrupted);
if (!IsInterrupted && Value != null && Value.IsSealed)
{
data = Value;
Result = true;
}
return(Result);
}
private static void PositionalArgumentMatching(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, int i, ref int maximumAllowedArgumentCount, ref ISealableList <IParameter> selectedOverload, ref int selectedIndex)
{
ISealableList <IParameter> OverloadParameterList = parameterTableList[i];
int j;
bool IsMatching = true;
for (j = 0; j < arguments.Count && j < OverloadParameterList.Count && IsMatching; j++)
{
ICompiledType ArgumentType = arguments[j].ValueType;
IParameter OverloadParameter = OverloadParameterList[j];
ICompiledType ParameterType = TypeOfPositionalParameter(OverloadParameter);
IsMatching &= ObjectType.TypeConformToBase(ArgumentType, ParameterType, isConversionAllowed: true);
}
if (IsMatching)
{
if (maximumAllowedArgumentCount < OverloadParameterList.Count)
{
maximumAllowedArgumentCount = OverloadParameterList.Count;
}
for (; j < OverloadParameterList.Count && IsMatching; j++)
{
IParameter OverloadParameter = OverloadParameterList[j];
IsMatching &= OverloadParameter.ResolvedParameter.DefaultValue.IsAssigned;
}
}
if (IsMatching && j >= arguments.Count)
{
bool IsBetter = false;
if (selectedOverload != null)
{
IsBetter = SelectMatchingOverload(OverloadParameterList, selectedOverload);
}
if (selectedOverload == null || IsBetter)
{
selectedOverload = OverloadParameterList;
selectedIndex = i;
}
}
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IBinaryOperatorExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item4;
IFunctionFeature SelectedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item5;
IQueryOverload SelectedOverload = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item6;
IFeatureCall FeatureCall = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item7;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.SelectedFeature.Item = SelectedFeature;
node.SelectedOverload.Item = SelectedOverload;
node.FeatureCall.Item = FeatureCall;
}
private static bool SelectMatchingOverload(ISealableList <IParameter> overloadParameterList, ISealableList <IParameter> selectedOverload)
{
bool IsBetter = false;
for (int j = 0; j < overloadParameterList.Count && j < selectedOverload.Count; j++)
{
IParameter OverloadParameter = overloadParameterList[j];
ICompiledType OverloadParameterType = TypeOfPositionalParameter(OverloadParameter);
IParameter SelectedParameter = selectedOverload[j];
ICompiledType SelectedParameterType = TypeOfPositionalParameter(SelectedParameter);
if (OverloadParameterType != SelectedParameterType)
{
IsBetter |= ObjectType.TypeConformToBase(OverloadParameterType, SelectedParameterType, isConversionAllowed: false);
}
}
return(IsBetter);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IClassConstantExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item4;
Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> AdditionalData = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item5;
IConstantFeature ResolvedFinalFeature = AdditionalData.Item1;
IDiscrete ResolvedFinalDiscrete = AdditionalData.Item2;
ITypeName ResolvedClassTypeName = AdditionalData.Item3;
IClassType ResolvedClassType = AdditionalData.Item4;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
if (ConstantSourceList.Count == 0)
{
IDiscreteLanguageConstant DiscreteLanguageConstant = ExpressionConstant as IDiscreteLanguageConstant;
Debug.Assert(DiscreteLanguageConstant != null);
Debug.Assert(DiscreteLanguageConstant.IsValueKnown);
node.ExpressionConstant.Item = ExpressionConstant;
}
else
{
Debug.Assert(ConstantSourceList.Count == 1);
}
node.ResolvedClassTypeName.Item = ResolvedClassTypeName;
node.ResolvedClassType.Item = ResolvedClassType;
Debug.Assert(ResolvedFinalFeature != null || ResolvedFinalDiscrete != null);
if (ResolvedFinalFeature != null)
{
node.ResolvedFinalFeature.Item = ResolvedFinalFeature;
}
if (ResolvedFinalDiscrete != null)
{
node.ResolvedFinalDiscrete.Item = ResolvedFinalDiscrete;
}
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item5;
IDiscrete ResolvedFinalDiscrete = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item6;
node.ResolvedException.Item = ResolvedException;
if (ResolvedFinalFeature != null)
{
node.ResolvedFinalFeature.Item = ResolvedFinalFeature;
}
if (ResolvedFinalDiscrete != null)
{
node.ResolvedFinalDiscrete.Item = ResolvedFinalDiscrete;
}
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IQueryOverloadType node, object data)
{
IClass EmbeddingClass = node.EmbeddingClass;
ISealableList <IParameter> ParameterTable = ((Tuple <ISealableList <IParameter>, ISealableList <IParameter> >)data).Item1;
ISealableList <IParameter> ResultTable = ((Tuple <ISealableList <IParameter>, ISealableList <IParameter> >)data).Item2;
Debug.Assert(node.ParameterTable.Count == 0);
Debug.Assert(node.ResultTable.Count == 0);
node.ParameterTable.AddRange(ParameterTable);
node.ParameterTable.Seal();
node.ResultTable.AddRange(ResultTable);
node.ResultTable.Seal();
foreach (IParameter Parameter in ResultTable)
{
Debug.Assert(Parameter.ResolvedParameter.ResolvedEffectiveType.IsAssigned);
node.ConformantResultTable.Add(Parameter.ResolvedParameter.ResolvedEffectiveType.Item);
}
}
/// <summary>
/// Checks the validity of an assignment of a source to a destination, with arguments.
/// </summary>
/// <param name="parameterTableList">The list of expected parameters.</param>
/// <param name="resultTableList">The list of results.</param>
/// <param name="argumentList">The list of actual arguments.</param>
/// <param name="sourceExpression">Expression in the assignment.</param>
/// <param name="destinationType">The expected type for the expression.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="source">The source to use when reporting errors.</param>
/// <param name="featureCall">Details of the feature call.</param>
public static bool CheckAssignmentConformance(IList <ISealableList <IParameter> > parameterTableList, IList <ISealableList <IParameter> > resultTableList, IList <IArgument> argumentList, IExpression sourceExpression, ICompiledType destinationType, IErrorList errorList, ISource source, out IFeatureCall featureCall)
{
featureCall = null;
IResultType SourceResult = sourceExpression.ResolvedResult.Item;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(argumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList))
{
return(false);
}
if (!Argument.ArgumentsConformToParameters(parameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, source, out int SelectedIndex))
{
return(false);
}
if (SourceResult.Count != 1)
{
errorList.AddError(new ErrorInvalidExpression(sourceExpression));
return(false);
}
ISealableList <IParameter> SelectedParameterList = parameterTableList[SelectedIndex];
ISealableList <IParameter> SelectedResultList = resultTableList[SelectedIndex];
ICompiledType SourceType = SourceResult.At(0).ValueType;
if (!ObjectType.TypeConformToBase(SourceType, destinationType, errorList, sourceExpression, isConversionAllowed: true))
{
errorList.AddError(new ErrorInvalidExpression(sourceExpression));
return(false);
}
featureCall = new FeatureCall(SelectedParameterList, SelectedResultList, argumentList, MergedArgumentList, TypeArgumentStyle);
return(true);
}
/// <summary>
/// Adds to a list of constant sources from a list of arguments.
/// </summary>
/// <param name="argumentList">The list of arguments.</param>
/// <param name="constantSourceList">The list of constant sources.</param>
public static void AddConstantArguments(IList <IArgument> argumentList, ISealableList <IExpression> constantSourceList)
{
Debug.Assert(argumentList.Count > 0);
foreach (IArgument Argument in argumentList)
{
IExpression ArgumentSource = null;
switch (Argument)
{
case IPositionalArgument AsPositionalArgument:
ArgumentSource = (IExpression)AsPositionalArgument.Source;
break;
case IAssignmentArgument AsAssignmentArgument:
ArgumentSource = (IExpression)AsAssignmentArgument.Source;
break;
}
Debug.Assert(ArgumentSource != null);
constantSourceList.Add(ArgumentSource);
}
}
/// <summary>
/// Finds the matching nodes of a <see cref="IUnaryNotExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The constant value upon return, if any.</param>
public static bool ResolveCompilerReferences(IUnaryNotExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
IExpression RightExpression = (IExpression)node.RightExpression;
IClass EmbeddingClass = node.EmbeddingClass;
bool IsRightClassType = Expression.GetClassTypeOfExpression(RightExpression, errorList, out IClassType RightExpressionClassType);
if (!IsRightClassType)
{
return(false);
}
Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType);
Expression.IsLanguageTypeAvailable(LanguageClasses.Event.Guid, node, out ITypeName EventTypeName, out ICompiledType EventType);
Debug.Assert(RightExpressionClassType == BooleanType || RightExpressionClassType == EventType);
node.SetIsEventExpression(RightExpressionClassType != BooleanType);
constantSourceList.Add(RightExpression);
resolvedResult = new ResultType(BooleanTypeName, BooleanType, string.Empty);
ResultException.Propagate(RightExpression.ResolvedException, out resolvedException);
#if COVERAGE
Debug.Assert(node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Adds to a list of constant sources from a list of arguments.
/// </summary>
/// <param name="expression">The source expression.</param>
/// <param name="resultType">The expression result type.</param>
/// <param name="argumentList">The list of arguments.</param>
/// <param name="constantSourceList">The list of constant sources.</param>
/// <param name="expressionConstant">The constant if there are no arguments upon return.</param>
public static void AddConstantArguments(IExpression expression, IResultType resultType, IList <IArgument> argumentList, ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
{
if (argumentList.Count == 0)
{
expressionConstant = Expression.GetDefaultConstant(expression, resultType);
}
else
{
expressionConstant = NeutralLanguageConstant.NotConstant;
AddConstantArguments(argumentList, constantSourceList);
}
}
private static bool AssignmentArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, IErrorList errorList, ISource source, out int selectedIndex)
{
ISealableList <IParameter> SelectedOverload = null;
selectedIndex = -1;
for (int i = 0; i < parameterTableList.Count; i++)
{
ISealableList <IParameter> OverloadParameterList = parameterTableList[i];
List <IParameter> UnassignedParameters = new List <IParameter>(OverloadParameterList);
bool IsMatching = true;
for (int j = 0; j < arguments.Count && IsMatching; j++)
{
ICompiledType ArgumentType = arguments[j].ValueType;
string ArgumentName = arguments[j].Name;
OnceReference <IParameter> MatchingParameter = new OnceReference <IParameter>();
foreach (IParameter p in OverloadParameterList)
{
if (p.Name == ArgumentName)
{
MatchingParameter.Item = p;
break;
}
}
if (!MatchingParameter.IsAssigned)
{
errorList.AddError(new ErrorArgumentNameMismatch(source, ArgumentName));
return(false);
}
IParameter OverloadParameter = MatchingParameter.Item;
UnassignedParameters.Remove(OverloadParameter);
ICompiledType ParameterType = OverloadParameter.ResolvedParameter.ResolvedEffectiveType.Item;
IsMatching &= ObjectType.TypeConformToBase(ArgumentType, ParameterType, isConversionAllowed: true);
}
foreach (IParameter OverloadParameter in UnassignedParameters)
{
IsMatching &= OverloadParameter.ResolvedParameter.DefaultValue.IsAssigned;
}
if (IsMatching)
{
Debug.Assert(SelectedOverload == null);
SelectedOverload = OverloadParameterList;
selectedIndex = i;
}
}
if (SelectedOverload == null)
{
errorList.AddError(new ErrorInvalidExpression(source));
return(false);
}
else
{
return(true);
}
}
