private static bool ProcedureTypeConformToIndexerTypeOverloads(ICommandOverloadType derivedOverload, IIndexerType baseType, IErrorList errorList, ISource sourceLocation)
{
bool Result = true;
Result &= derivedOverload.ParameterList.Count == baseType.IndexParameterList.Count + 1 && derivedOverload.ParameterEnd == BaseNode.ParameterEndStatus.Closed;
for (int i = 0; i + 1 < derivedOverload.ParameterList.Count && i < baseType.IndexParameterList.Count; i++)
{
IEntityDeclaration BaseParameter = baseType.IndexParameterList[i];
IEntityDeclaration DerivedParameter = derivedOverload.ParameterList[i];
Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
}
if (derivedOverload.ParameterList.Count == baseType.IndexParameterList.Count + 1)
{
IEntityDeclaration OverloadValue = derivedOverload.ParameterList[baseType.IndexParameterList.Count];
Debug.Assert(OverloadValue.ValidEntity.IsAssigned);
Debug.Assert(OverloadValue.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Debug.Assert(baseType.ResolvedEntityType.IsAssigned);
Result &= TypeConformToBase(OverloadValue.ValidEntity.Item.ResolvedEffectiveType.Item, baseType.ResolvedEntityType.Item, ErrorList.Ignored, ErrorList.NoLocation, isConversionAllowed: false);
Result &= ExceptionListConformToBase(derivedOverload.ExceptionIdentifierList, baseType.SetExceptionIdentifierList, errorList, sourceLocation);
}
return(Result);
}
/// <summary>
/// Compares two overloads.
/// </summary>
/// <param name="overload1">The first overload.</param>
/// <param name="overload2">The second overload.</param>
public static bool CommandOverloadsHaveIdenticalSignature(ICommandOverloadType overload1, ICommandOverloadType overload2)
{
bool IsIdentical = true;
IsIdentical &= overload1.ParameterList.Count == overload2.ParameterList.Count;
IsIdentical &= overload1.ParameterEnd == overload2.ParameterEnd;
for (int i = 0; i < overload1.ParameterList.Count && i < overload2.ParameterList.Count; i++)
{
Debug.Assert(overload1.ParameterList[i].ValidEntity.IsAssigned);
Debug.Assert(overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Debug.Assert(overload2.ParameterList[i].ValidEntity.IsAssigned);
Debug.Assert(overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
ICompiledType Type1 = overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item;
ICompiledType Type2 = overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item;
IsIdentical &= ObjectType.TypesHaveIdenticalSignature(Type1, Type2);
}
IsIdentical &= Assertion.IsAssertionListEqual(overload1.RequireList, overload2.RequireList);
IsIdentical &= Assertion.IsAssertionListEqual(overload1.EnsureList, overload2.EnsureList);
IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(overload1.ExceptionIdentifierList, overload2.ExceptionIdentifierList);
return(IsIdentical);
}
/// <summary>
/// Initializes the feature precursor hierarchy.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitHierarchy(ICSharpContext context)
{
if (Instance.OriginalPrecursor.IsAssigned)
{
IPrecursorInstance Item = Instance.OriginalPrecursor.Item;
ICompiledFeature PrecursorFeature = Item.Precursor.Feature;
OriginalPrecursor = context.GetFeature(PrecursorFeature) as ICSharpProcedureFeature;
Debug.Assert(OriginalPrecursor != null);
IList <ICSharpOverload> PrecursorOverloadList = OriginalPrecursor.OverloadList;
foreach (ICSharpCommandOverload Overload in OverloadList)
{
ICommandOverloadType ResolvedAssociatedType = Overload.Source.ResolvedAssociatedType.Item;
ICSharpCommandOverload ParentPrecursorOverload = null;
foreach (ICSharpCommandOverload PrecursorOverload in PrecursorOverloadList)
{
ICommandOverloadType PrecursorResolvedAssociatedType = PrecursorOverload.Source.ResolvedAssociatedType.Item;
if (ObjectType.CommandOverloadConformToBase(ResolvedAssociatedType, PrecursorResolvedAssociatedType, ErrorList.Ignored, ErrorList.NoLocation))
{
Debug.Assert(ParentPrecursorOverload == null);
ParentPrecursorOverload = PrecursorOverload;
}
}
Debug.Assert(ParentPrecursorOverload != null);
Overload.SetPrecursor(ParentPrecursorOverload);
}
}
}
/// <summary>
/// Checks that a command overload conforms to another.
/// </summary>
/// <param name="derivedType">The derived type.</param>
/// <param name="baseType">The base type.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="sourceLocation">The location for reporting errors.</param>
public static bool CommandOverloadConformToBase(ICommandOverloadType derivedType, ICommandOverloadType baseType, IErrorList errorList, ISource sourceLocation)
{
bool Result = true;
if (baseType.ParameterList.Count != derivedType.ParameterList.Count || baseType.ParameterEnd != derivedType.ParameterEnd)
{
errorList.AddError(new ErrorParameterMismatchConformance(sourceLocation, derivedType, baseType));
Result = false;
}
for (int i = 0; i < baseType.ParameterList.Count && i < derivedType.ParameterList.Count; i++)
{
IEntityDeclaration BaseParameter = baseType.ParameterList[i];
IEntityDeclaration DerivedParameter = derivedType.ParameterList[i];
Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
}
Result &= ExceptionListConformToBase(derivedType.ExceptionIdentifierList, baseType.ExceptionIdentifierList, errorList, sourceLocation);
return(Result);
}
/// <summary>
/// Creates an instance of a class type, or reuse an existing instance.
/// </summary>
/// <param name="instancingClassType">The class type to instanciate.</param>
/// <param name="resolvedTypeName">The proposed type instance name.</param>
/// <param name="resolvedType">The proposed type instance.</param>
public void InstanciateType(ICompiledTypeWithFeature instancingClassType, ref ITypeName resolvedTypeName, ref ICompiledType resolvedType)
{
bool IsNewInstance = false;
ITypeName InstancedBaseTypeName = ResolvedBaseTypeName.Item;
ICompiledType InstancedBaseType = ResolvedBaseType.Item;
InstancedBaseType.InstanciateType(instancingClassType, ref InstancedBaseTypeName, ref InstancedBaseType);
IsNewInstance |= InstancedBaseType != ResolvedBaseType.Item;
IList <ICommandOverloadType> InstancedOverloadList = new List <ICommandOverloadType>();
foreach (ICommandOverloadType Overload in OverloadList)
{
ICommandOverloadType InstancedOverload = Overload;
CommandOverloadType.InstanciateCommandOverloadType(instancingClassType, ref InstancedOverload);
IsNewInstance |= InstancedOverload != Overload;
InstancedOverloadList.Add(InstancedOverload);
}
if (IsNewInstance)
{
ISealableDictionary <ITypeName, ICompiledType> TypeTable = instancingClassType.GetTypeTable();
ResolveType(TypeTable, InstancedBaseTypeName, (IObjectType)BaseType, (ICompiledTypeWithFeature)InstancedBaseType, InstancedOverloadList, out resolvedTypeName, out IProcedureType ResolvedProcedureType);
resolvedType = ResolvedProcedureType;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ErrorOverloadParameterMismatchConformance"/> class.
/// </summary>
/// <param name="source">The error location.</param>
/// <param name="derivedType">The derived type</param>
/// <param name="baseType">The base type.</param>
public ErrorOverloadParameterMismatchConformance(ISource source, ICommandOverloadType derivedType, ICompiledType baseType)
: base(source)
{
DerivedParameterList = derivedType.ParameterList;
DerivedParameterEnd = derivedType.ParameterEnd;
BaseType = baseType;
}
private static bool IndexerTypeConformToProcedureType(IIndexerType derivedType, IProcedureType baseType, IErrorList errorList, ISource sourceLocation)
{
bool Result = true;
Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
Debug.Assert(baseType.ResolvedBaseType.IsAssigned);
Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);
if (derivedType.IndexerKind == BaseNode.UtilityType.ReadOnly)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
if (baseType.OverloadList.Count > 1)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
ICommandOverloadType SingleOverload = baseType.OverloadList[0];
if (SingleOverload.ParameterList.Count != derivedType.IndexParameterList.Count + 1 || SingleOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
for (int i = 0; i + 1 < SingleOverload.ParameterList.Count && i < derivedType.IndexParameterList.Count; i++)
{
IEntityDeclaration BaseParameter = SingleOverload.ParameterList[i];
IEntityDeclaration DerivedParameter = derivedType.IndexParameterList[i];
Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
}
if (SingleOverload.ParameterList.Count == derivedType.IndexParameterList.Count + 1)
{
Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);
IEntityDeclaration LastParameter = SingleOverload.ParameterList[derivedType.IndexParameterList.Count];
Debug.Assert(LastParameter.ValidEntity.IsAssigned);
Debug.Assert(LastParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(derivedType.ResolvedEntityType.Item, LastParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
}
Result &= ExceptionListConformToBase(derivedType.SetExceptionIdentifierList, SingleOverload.ExceptionIdentifierList, errorList, sourceLocation);
return(Result);
}
/// <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(ICommandInstruction node, object data)
{
IResultException ResolvedException = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item1;
ICompiledFeature SelectedFeature = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item2;
ICommandOverloadType SelectedOverload = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item3;
IFeatureCall FeatureCall = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item4;
IProcedureType CommandFinalType = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item5;
node.ResolvedException.Item = ResolvedException;
node.SelectedFeature.Item = SelectedFeature;
node.SelectedOverload.Item = SelectedOverload;
node.FeatureCall.Item = FeatureCall;
node.CommandFinalType.Item = CommandFinalType;
}
private static bool PropertyTypeConformToProcedureType(IPropertyType derivedType, IProcedureType baseType, IErrorList errorList, ISource sourceLocation)
{
bool Result = true;
Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
Debug.Assert(baseType.ResolvedBaseType.IsAssigned);
Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);
if (derivedType.PropertyKind == BaseNode.UtilityType.ReadOnly)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
if (baseType.OverloadList.Count > 1)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
ICommandOverloadType SingleOverload = baseType.OverloadList[0];
if (SingleOverload.ParameterList.Count != 1 || SingleOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed)
{
errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
Result = false;
}
if (SingleOverload.ParameterList.Count == 1)
{
IEntityDeclaration OverloadValue = SingleOverload.ParameterList[0];
Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);
Debug.Assert(OverloadValue.ValidEntity.IsAssigned);
Debug.Assert(OverloadValue.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(derivedType.ResolvedEntityType.Item, OverloadValue.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
Result &= ExceptionListConformToBase(derivedType.SetExceptionIdentifierList, SingleOverload.ExceptionIdentifierList, errorList, sourceLocation);
}
return(Result);
}
private static bool CommandOverloadHasPropertyConformingBase(ICommandOverloadType derivedOverload, IPropertyType baseType, IErrorList errorList, ISource sourceLocation)
{
bool Result = true;
if (derivedOverload.ParameterList.Count != 1 || derivedOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed)
{
errorList.AddError(new ErrorOverloadParameterMismatchConformance(sourceLocation, derivedOverload, baseType));
Result = false;
}
if (derivedOverload.ParameterList.Count == 1)
{
IEntityDeclaration OverloadValue = derivedOverload.ParameterList[0];
Debug.Assert(OverloadValue.ValidEntity.IsAssigned);
Debug.Assert(OverloadValue.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
Result &= TypeConformToBase(OverloadValue.ValidEntity.Item.ResolvedEffectiveType.Item, baseType.ResolvedEntityType.Item, errorList, sourceLocation, isConversionAllowed: false);
}
Result &= ExceptionListConformToBase(derivedOverload.ExceptionIdentifierList, baseType.SetExceptionIdentifierList, errorList, sourceLocation);
return(Result);
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IThrowInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IObjectType ThrowExceptionType = (IObjectType)node.ExceptionType;
ICompiledType ResolvedType = ThrowExceptionType.ResolvedType.Item;
IIdentifier CreationRoutine = (IIdentifier)node.CreationRoutine;
string ValidText = CreationRoutine.ValidText.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Exception.Guid, node, out ITypeName ExceptionTypeName, out ICompiledType ExceptionType))
{
AddSourceError(new ErrorExceptionTypeMissing(node));
return(false);
}
if (!ObjectType.TypeConformToBase(ResolvedType, ExceptionType, isConversionAllowed: true))
{
AddSourceError(new ErrorExceptionTypeRequired(node));
return(false);
}
if (!FeatureName.TableContain(ResolvedType.FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Value))
{
AddSourceError(new ErrorUnknownIdentifier(CreationRoutine, ValidText));
return(false);
}
if (Value.Feature is CreationFeature AsCreationFeature)
{
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(node.ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
Debug.Assert(AsCreationFeature.ResolvedAgentType.IsAssigned);
ICompiledType FinalType = AsCreationFeature.ResolvedAgentType.Item;
IProcedureType AsProcedureType = FinalType as IProcedureType;
Debug.Assert(AsProcedureType != null);
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, ErrorList, node, out int SelectedIndex))
{
return(false);
}
ICommandOverloadType SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
IResultException ResolvedException = new ResultException();
ResolvedException.Add(ValidText);
Debug.Assert(ResolvedException.At(0).Text == ValidText);
Debug.Assert(ResolvedException.At(0).ValidText.IsAssigned);
Debug.Assert(ResolvedException.At(0).ValidText.Item == ValidText);
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, SelectedOverload.ExceptionIdentifierList);
IFeatureCall FeatureCall = new FeatureCall(SelectedOverload.ParameterTable, new List <IParameter>(), node.ArgumentList, MergedArgumentList, TypeArgumentStyle);
data = new Tuple <ICompiledType, IResultException, IFeatureCall>(ResolvedType, ResolvedException, FeatureCall);
}
else
{
AddSourceError(new ErrorCreationFeatureRequired(CreationRoutine, ValidText));
return(false);
}
return(Success);
}
private string CommandOverloadType2CSharpString(string delegateName, ICommandOverloadType overload)
{
// TODO
return(delegateName);
}
/// <summary>
/// Finds or creates an overload type with the corresponding parameters.
/// </summary>
/// <param name="instancingClassType">The type attempting to find the overload type.</param>
/// <param name="instancedOverload">The new overload type upon return if not found.</param>
public static void InstanciateCommandOverloadType(ICompiledTypeWithFeature instancingClassType, ref ICommandOverloadType instancedOverload)
{
bool IsNewInstance = false;
IList <IEntityDeclaration> InstancedParameterList = new List <IEntityDeclaration>();
foreach (IEntityDeclaration Parameter in instancedOverload.ParameterList)
{
ITypeName InstancedParameterTypeName = Parameter.ValidEntity.Item.ResolvedEffectiveTypeName.Item;
ICompiledType InstancedParameterType = Parameter.ValidEntity.Item.ResolvedEffectiveType.Item;
InstancedParameterType.InstanciateType(instancingClassType, ref InstancedParameterTypeName, ref InstancedParameterType);
IEntityDeclaration InstancedParameter = new EntityDeclaration(Parameter, InstancedParameterTypeName, InstancedParameterType);
IName ParameterName = (IName)Parameter.EntityName;
IScopeAttributeFeature NewEntity;
if (Parameter.DefaultValue.IsAssigned)
{
// The default value has already been checked and validated.
bool IsCreated = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType, (IExpression)Parameter.DefaultValue.Item, ErrorList.Ignored, out NewEntity);
Debug.Assert(IsCreated);
}
else
{
NewEntity = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType);
}
InstancedParameter.ValidEntity.Item = NewEntity;
InstancedParameterList.Add(InstancedParameter);
if (InstancedParameterType != Parameter.ValidEntity.Item.ResolvedEffectiveType.Item)
{
IsNewInstance = true;
}
}
if (IsNewInstance)
{
ICommandOverloadType NewOverloadInstance = new CommandOverloadType(InstancedParameterList, instancedOverload.ParameterEnd, instancedOverload.RequireList, instancedOverload.EnsureList, instancedOverload.ExceptionIdentifierList);
foreach (IEntityDeclaration Item in InstancedParameterList)
{
string ValidName = Item.ValidEntity.Item.ValidFeatureName.Item.Name;
NewOverloadInstance.ParameterTable.Add(new Parameter(ValidName, Item.ValidEntity.Item));
}
instancedOverload = NewOverloadInstance;
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IPrecursorInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = EmbeddingClass.FeatureTable;
IFeature InnerFeature = node.EmbeddingFeature;
if (InnerFeature is IIndexerFeature AsIndexerFeature)
{
AddSourceError(new ErrorPrecursorNotAllowedInIndexer(node));
return(false);
}
else
{
IFeature AsNamedFeature = InnerFeature;
IFeatureInstance Instance = FeatureTable[AsNamedFeature.ValidFeatureName.Item];
OnceReference <IFeatureInstance> SelectedPrecursor = new OnceReference <IFeatureInstance>();
IList <IPrecursorInstance> PrecursorList = Instance.PrecursorList;
if (node.AncestorType.IsAssigned)
{
IObjectType DeclaredAncestor = (IObjectType)node.AncestorType.Item;
if (DeclaredAncestor.ResolvedType.Item is IClassType AsClassTypeAncestor)
{
foreach (IPrecursorInstance Item in PrecursorList)
{
if (Item.Ancestor.BaseClass == AsClassTypeAncestor.BaseClass)
{
SelectedPrecursor.Item = Item.Precursor;
break;
}
}
}
if (!SelectedPrecursor.IsAssigned)
{
AddSourceError(new ErrorInvalidPrecursor(DeclaredAncestor));
return(false);
}
}
else if (Instance.PrecursorList.Count > 1)
{
AddSourceError(new ErrorInvalidPrecursor(node));
return(false);
}
else if (Instance.PrecursorList.Count == 0)
{
AddSourceError(new ErrorNoPrecursor(node));
return(false);
}
else
{
SelectedPrecursor.Item = Instance.PrecursorList[0].Precursor;
}
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(node.ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ICompiledFeature OperatorFeature = SelectedPrecursor.Item.Feature;
ICompiledType OperatorType = OperatorFeature.ResolvedAgentType.Item;
IList <IIdentifier> PrecursorInstructionException = null;
ISealableList <IParameter> SelectedParameterList = null;
// This has been checked in the type pass.
IProcedureType AsProcedureType = OperatorType as IProcedureType;
Debug.Assert(AsProcedureType != null);
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, ErrorList, node, out int SelectedIndex))
{
return(false);
}
ICommandOverloadType SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
PrecursorInstructionException = SelectedOverload.ExceptionIdentifierList;
SelectedParameterList = SelectedOverload.ParameterTable;
IResultException ResolvedException = new ResultException();
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, PrecursorInstructionException);
IFeatureCall FeatureCall = new FeatureCall(SelectedParameterList, new List <IParameter>(), node.ArgumentList, MergedArgumentList, TypeArgumentStyle);
data = new Tuple <IResultException, IFeatureCall>(ResolvedException, FeatureCall);
}
return(Success);
}
/// <summary>
/// Checks if a matching procedure and overload exists in a type table.
/// </summary>
/// <param name="typeTable">The table of existing types.</param>
/// <param name="overload">The overload to check.</param>
/// <param name="overloadList">The list of other overloads in the candidate procedure type.</param>
public static bool IsCommandOverloadMatching(ISealableDictionary <ITypeName, ICompiledType> typeTable, ICommandOverloadType overload, IList <ICommandOverloadType> overloadList)
{
bool IsOverloadFound = false;
foreach (ICommandOverloadType Item in overloadList)
{
bool IsMatching = true;
IsMatching &= overload.ParameterList.Count == Item.ParameterList.Count;
for (int i = 0; i < overload.ParameterList.Count && i < Item.ParameterList.Count; i++)
{
IsMatching &= overload.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item == Item.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item;
IsMatching &= overload.ParameterList[i].ValidEntity.Item.DefaultValue.IsAssigned == Item.ParameterList[i].ValidEntity.Item.DefaultValue.IsAssigned;
IsMatching &= IsDefaultValueMatching(overload.ParameterList[i].ValidEntity.Item.DefaultValue, Item.ParameterList[i].ValidEntity.Item.DefaultValue);
if (IsMatching)
{
IName overloadName = (IName)overload.ParameterList[i].EntityName;
IName ItemName = (IName)Item.ParameterList[i].EntityName;
Debug.Assert(overloadName != null);
Debug.Assert(ItemName != null);
IsMatching &= overloadName.ValidText.Item == ItemName.ValidText.Item;
}
}
IsMatching &= overload.ParameterEnd == Item.ParameterEnd;
IsMatching &= Assertion.IsAssertionListEqual(overload.RequireList, Item.RequireList);
IsMatching &= Assertion.IsAssertionListEqual(overload.EnsureList, Item.EnsureList);
IsMatching &= ExceptionHandler.IdenticalExceptionSignature(overload.ExceptionIdentifierList, Item.ExceptionIdentifierList);
IsOverloadFound |= IsMatching;
}
return(IsOverloadFound);
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(ICommandInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IQualifiedName Command = (IQualifiedName)node.Command;
IList <IIdentifier> ValidPath = Command.ValidPath.Item;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, ErrorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute))
{
return(false);
}
Debug.Assert(FinalFeature != null);
IList <IArgument> ArgumentList = node.ArgumentList;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles ArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ICommandOverloadType SelectedOverload = null;
ISealableList <IParameter> SelectedParameterList = null;
IProcedureType CommandFinalType = null;
bool IsHandled = false;
switch (FinalType)
{
case IFunctionType AsFunctionType:
case IPropertyType AsPropertyType:
AddSourceError(new ErrorInvalidInstruction(node));
Success = false;
IsHandled = true;
break;
case IProcedureType AsProcedureType:
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
int SelectedIndex;
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, ArgumentStyle, ErrorList, node, out SelectedIndex))
{
Success = false;
}
else
{
SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
SelectedParameterList = ParameterTableList[SelectedIndex];
CommandFinalType = AsProcedureType;
}
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
if (Success)
{
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Command.ValidResultTypePath.Item);
IResultException ResolvedException = new ResultException();
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
IList <IIdentifier> CommandInstructionException = SelectedOverload.ExceptionIdentifierList;
ResultException.Merge(ResolvedException, CommandInstructionException);
IFeatureCall FeatureCall = new FeatureCall(SelectedParameterList, new List <IParameter>(), ArgumentList, MergedArgumentList, ArgumentStyle);
data = new Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>(ResolvedException, FinalFeature, SelectedOverload, FeatureCall, CommandFinalType);
}
return(Success);
}
