/// <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(IForLoopInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
IClass EmbeddingClass = node.EmbeddingClass;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = new SealableDictionary <string, IScopeAttributeFeature>();
foreach (IEntityDeclaration Item in node.EntityDeclarationList)
{
IScopeAttributeFeature LocalEntity = Item.ValidEntity.Item;
string ValidFeatureName = LocalEntity.ValidFeatureName.Item.Name;
if (CheckedScope.ContainsKey(ValidFeatureName))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidFeatureName));
Success = false;
}
else
{
CheckedScope.Add(ValidFeatureName, LocalEntity);
}
}
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedScope, node.InnerScopes, ConflictList);
foreach (IEntityDeclaration Item in node.EntityDeclarationList)
{
IScopeAttributeFeature LocalEntity = Item.ValidEntity.Item;
string ValidFeatureName = LocalEntity.ValidFeatureName.Item.Name;
if (ConflictList.Contains(ValidFeatureName))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidFeatureName));
Success = false;
}
}
IList <IClass> AssignedSingleClassList = new List <IClass>();
IErrorList CheckErrorList = new ErrorList();
if (ScopeHolder.HasConflictingSingleAttributes(CheckedScope, node.InnerScopes, AssignedSingleClassList, node, CheckErrorList))
{
AddSourceErrorList(CheckErrorList);
Success = false;
}
if (Success)
{
data = CheckedScope;
}
return(Success);
}
/// <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(ICommandOverload node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = new SealableDictionary <string, IScopeAttributeFeature>();
ISealableList <IParameter> ParameterTable = new SealableList <IParameter>();
foreach (EntityDeclaration Item in node.ParameterList)
{
IName SourceName = (IName)Item.EntityName;
string ValidName = SourceName.ValidText.Item;
if (CheckedScope.ContainsKey(ValidName))
{
AddSourceError(new ErrorDuplicateName(SourceName, ValidName));
Success = false;
}
else
{
CheckedScope.Add(ValidName, Item.ValidEntity.Item);
ParameterTable.Add(new Parameter(ValidName, Item.ValidEntity.Item));
}
}
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedScope, node.InnerScopes, ConflictList);
foreach (IEntityDeclaration Item in node.ParameterList)
{
IScopeAttributeFeature LocalEntity = Item.ValidEntity.Item;
string ValidFeatureName = LocalEntity.ValidFeatureName.Item.Name;
if (ConflictList.Contains(ValidFeatureName))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidFeatureName));
Success = false;
}
}
if (Success)
{
data = new Tuple <ISealableDictionary <string, IScopeAttributeFeature>, ISealableList <IParameter> >(CheckedScope, ParameterTable);
}
return(Success);
}
/// <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(IOverLoopInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = new SealableDictionary <string, IScopeAttributeFeature>();
IClass EmbeddingClass = node.EmbeddingClass;
foreach (IName Item in node.IndexerList)
{
Debug.Assert(Item.ValidText.IsAssigned);
string ValidText = Item.ValidText.Item;
if (CheckedScope.ContainsKey(ValidText))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidText));
Success = false;
}
else
{
IScopeAttributeFeature NewEntity = ScopeAttributeFeature.Create(Item, ValidText);
CheckedScope.Add(ValidText, NewEntity);
}
}
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedScope, node.InnerScopes, ConflictList);
foreach (KeyValuePair <string, IScopeAttributeFeature> Item in CheckedScope)
{
if (ConflictList.Contains(Item.Key))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item.Value.Location, Item.Key));
Success = false;
}
}
if (Success)
{
data = CheckedScope;
}
return(Success);
}
private bool CheckResultValueConsistency(IIndexerFeature node, IDictionary <ISourceTemplate, object> dataList, IScopeAttributeFeature resultFeature, IScopeAttributeFeature valueFeature, out object data)
{
data = null;
bool Success = true;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = new SealableDictionary <string, IScopeAttributeFeature>();
ISealableDictionary <string, IScopeAttributeFeature> CheckedGetScope = new SealableDictionary <string, IScopeAttributeFeature>();
ISealableDictionary <string, IScopeAttributeFeature> CheckedSetScope = new SealableDictionary <string, IScopeAttributeFeature>();
string NameResult = resultFeature.ValidFeatureName.Item.Name;
string NameValue = valueFeature.ValidFeatureName.Item.Name;
Success &= CheckParameters(node, resultFeature, valueFeature, CheckedScope);
CheckedGetScope.Merge(CheckedScope);
CheckedGetScope.Add(NameResult, resultFeature);
CheckedSetScope.Merge(CheckedScope);
CheckedSetScope.Add(NameValue, valueFeature);
List <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedGetScope, node.InnerScopes, ConflictList);
ScopeHolder.RecursiveCheck(CheckedSetScope, node.InnerScopes, ConflictList);
Debug.Assert(node.InnerScopes.Count == 0);
// This has been checked in another rule.
Debug.Assert(!ConflictList.Contains(NameResult));
Debug.Assert(!ConflictList.Contains(NameValue));
Success &= CheckIndexerKind(node, out BaseNode.UtilityType IndexerKind);
if (Success)
{
data = new Tuple <BaseNode.UtilityType, ISealableDictionary <string, IScopeAttributeFeature>, ISealableDictionary <string, IScopeAttributeFeature>, ISealableDictionary <string, IScopeAttributeFeature> >(IndexerKind, CheckedScope, CheckedGetScope, CheckedSetScope);
}
return(Success);
}
/// <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(IQueryOverload node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = new SealableDictionary <string, IScopeAttributeFeature>();
Debug.Assert(node.ParameterTable.Count == node.ParameterList.Count);
for (int i = 0; i < node.ParameterTable.Count; i++)
{
IParameter Parameter = node.ParameterTable[i];
IEntityDeclaration EntityDeclaration = node.ParameterList[i];
if (CheckedScope.ContainsKey(Parameter.Name))
{
AddSourceError(new ErrorDuplicateName(EntityDeclaration, Parameter.Name));
Success = false;
}
else
{
CheckedScope.Add(Parameter.Name, EntityDeclaration.ValidEntity.Item);
}
}
Debug.Assert(node.ResultTable.Count == node.ResultList.Count);
for (int i = 0; i < node.ResultTable.Count; i++)
{
IParameter Result = node.ResultTable[i];
IEntityDeclaration EntityDeclaration = node.ResultList[i];
if (CheckedScope.ContainsKey(Result.Name))
{
AddSourceError(new ErrorDuplicateName(EntityDeclaration, Result.Name));
Success = false;
}
else
{
CheckedScope.Add(Result.Name, EntityDeclaration.ValidEntity.Item);
}
}
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedScope, node.InnerScopes, ConflictList);
foreach (IEntityDeclaration Item in node.ParameterList)
{
IScopeAttributeFeature LocalEntity = Item.ValidEntity.Item;
string ValidFeatureName = LocalEntity.ValidFeatureName.Item.Name;
if (ConflictList.Contains(ValidFeatureName))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidFeatureName));
Success = false;
}
}
foreach (IEntityDeclaration Item in node.ResultList)
{
IScopeAttributeFeature LocalEntity = Item.ValidEntity.Item;
string ValidFeatureName = LocalEntity.ValidFeatureName.Item.Name;
if (ConflictList.Contains(ValidFeatureName))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidFeatureName));
Success = false;
}
}
if (Success)
{
data = CheckedScope;
}
return(Success);
}
/// <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(IPropertyFeature node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IClass EmbeddingClass = node.EmbeddingClass;
IObjectType TypeToResolve = (IObjectType)node.EntityType;
IScopeAttributeFeature Result = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node);
IScopeAttributeFeature Value = ScopeAttributeFeature.CreateValueFeature(TypeToResolve, EmbeddingClass, node);
string NameResult = Result.ValidFeatureName.Item.Name;
string NameValue = Value.ValidFeatureName.Item.Name;
ISealableDictionary <string, IScopeAttributeFeature> CheckedGetScope = new SealableDictionary <string, IScopeAttributeFeature>();
CheckedGetScope.Add(NameResult, Result);
ISealableDictionary <string, IScopeAttributeFeature> CheckedSetScope = new SealableDictionary <string, IScopeAttributeFeature>();
CheckedSetScope.Add(NameValue, Value);
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedGetScope, node.InnerScopes, ConflictList);
ScopeHolder.RecursiveCheck(CheckedSetScope, node.InnerScopes, ConflictList);
// This has been checked in another rule.
Debug.Assert(!ConflictList.Contains(NameResult));
Debug.Assert(!ConflictList.Contains(NameValue));
IName PropertyName = (IName)((IFeatureWithName)node).EntityName;
if (node.GetterBody.IsAssigned && node.SetterBody.IsAssigned)
{
ICompiledBody AsCompiledGetter = (ICompiledBody)node.GetterBody.Item;
ICompiledBody AsCompiledSetter = (ICompiledBody)node.SetterBody.Item;
if (AsCompiledGetter.IsDeferredBody != AsCompiledSetter.IsDeferredBody)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
if (node.PropertyKind != BaseNode.UtilityType.ReadWrite)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
else if (node.GetterBody.IsAssigned)
{
if (node.PropertyKind == BaseNode.UtilityType.WriteOnly)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
else if (node.SetterBody.IsAssigned)
{
if (node.PropertyKind == BaseNode.UtilityType.ReadOnly)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
if (Success)
{
data = new Tuple <IScopeAttributeFeature, IScopeAttributeFeature>(Result, Value);
}
return(Success);
}
/// <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(IAttachmentInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
IClass EmbeddingClass = node.EmbeddingClass;
IList <ISealableDictionary <string, IScopeAttributeFeature> > CheckedScopeList = new List <ISealableDictionary <string, IScopeAttributeFeature> >();
for (int i = 0; i < node.AttachmentList.Count; i++)
{
CheckedScopeList.Add(new SealableDictionary <string, IScopeAttributeFeature>());
}
for (int Index = 0; Index < node.EntityNameList.Count; Index++)
{
IName Item = node.EntityNameList[Index];
Debug.Assert(Item.ValidText.IsAssigned);
string ValidText = Item.ValidText.Item;
if (CheckedScopeList[0].ContainsKey(ValidText))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidText));
Success = false;
continue;
}
for (int i = 0; i < node.AttachmentList.Count; i++)
{
Attachment AttachmentItem = (Attachment)node.AttachmentList[i];
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = CheckedScopeList[i];
Debug.Assert(Index < AttachmentItem.AttachTypeList.Count);
IObjectType AttachedType = AttachmentItem.AttachTypeList[Index];
Debug.Assert(AttachedType.ResolvedTypeName.IsAssigned);
Debug.Assert(AttachedType.ResolvedType.IsAssigned);
IScopeAttributeFeature NewEntity = ScopeAttributeFeature.Create(Item, ValidText, AttachedType.ResolvedTypeName.Item, AttachedType.ResolvedType.Item);
CheckedScope.Add(ValidText, NewEntity);
}
}
IList <string> ConflictList = new List <string>();
for (int i = 0; i < node.AttachmentList.Count; i++)
{
IAttachment AttachmentItem = (Attachment)node.AttachmentList[i];
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = CheckedScopeList[i];
ScopeHolder.RecursiveCheck(CheckedScope, AttachmentItem.InnerScopes, ConflictList);
}
foreach (IName Item in node.EntityNameList)
{
Debug.Assert(Item.ValidText.IsAssigned);
string ValidText = Item.ValidText.Item;
if (ConflictList.Contains(ValidText))
{
AddSourceError(new ErrorVariableAlreadyDefined(Item, ValidText));
Success = false;
}
}
if (Success)
{
data = CheckedScopeList;
}
return(Success);
}