/// <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(ITupleType node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; ISealableDictionary <string, IScopeAttributeFeature> FieldTable = new SealableDictionary <string, IScopeAttributeFeature>(); foreach (IEntityDeclaration Item in node.EntityDeclarationList) { IName FieldName = (IName)Item.EntityName; Debug.Assert(FieldName.ValidText.IsAssigned); string ValidText = FieldName.ValidText.Item; IScopeAttributeFeature FieldAttribute = Item.ValidEntity.Item; if (FieldTable.ContainsKey(ValidText)) { AddSourceError(new ErrorDuplicateName(FieldName, ValidText)); Success = false; } else { FieldTable.Add(ValidText, FieldAttribute); } } if (Success) { data = FieldTable; } return(Success); }
private ISealableDictionary <IFeatureName, IIdentifier> MergeExportClassIdentifiers(IClass node, IExport export, ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > mergedExportTable, ref bool success) { IList <string> ListedClassList = new List <string>(); ISealableDictionary <IFeatureName, IIdentifier> ListedExportList = new SealableDictionary <IFeatureName, IIdentifier>(); for (int i = 0; i < export.ClassIdentifierList.Count; i++) { IIdentifier Identifier = export.ClassIdentifierList[i]; Debug.Assert(Identifier.ValidText.IsAssigned); string ValidText = Identifier.ValidText.Item; if (ValidText.ToUpperInvariant() == LanguageClasses.Any.Name.ToUpperInvariant()) { ListedClassList.Add(LanguageClasses.Any.Name); } else if (node.ImportedClassTable.ContainsKey(ValidText)) { ListedClassList.Add(ValidText); } else if (FeatureName.TableContain(mergedExportTable, ValidText, out IFeatureName Key, out ISealableDictionary <string, IClass> Item)) { if (ListedExportList.ContainsKey(Key)) { AddSourceError(new ErrorIdentifierAlreadyListed(Identifier, ValidText)); success = false; } else { ListedExportList.Add(Key, Identifier); } }
/// <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(IExportChange node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; ISealableDictionary <string, IIdentifier> IdentifierTable = new SealableDictionary <string, IIdentifier>(); foreach (IIdentifier Item in node.IdentifierList) { Debug.Assert(Item.ValidText.IsAssigned); string ValidText = Item.ValidText.Item; if (IdentifierTable.ContainsKey(ValidText)) { AddSourceError(new ErrorDuplicateName(Item, ValidText)); Success = false; } else { IdentifierTable.Add(ValidText, Item); } } if (Success) { data = IdentifierTable; } 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(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); }
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> /// 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(IConstraint node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; ISealableDictionary <IIdentifier, IIdentifier> RenameTable = new SealableDictionary <IIdentifier, IIdentifier>(); ISealableDictionary <string, string> SourceToDestinationTable = new SealableDictionary <string, string>(); ISealableDictionary <string, string> DestinationToSourceTable = new SealableDictionary <string, string>(); foreach (IRename Item in node.RenameList) { IIdentifier SourceIdentifier = (IIdentifier)Item.SourceIdentifier; Debug.Assert(SourceIdentifier.ValidText.IsAssigned); string ValidSourceIdentifier = SourceIdentifier.ValidText.Item; Debug.Assert(Item.ValidSourceText.IsAssigned); Debug.Assert(Item.ValidSourceText.Item == ValidSourceIdentifier); IIdentifier DestinationIdentifier = (IIdentifier)Item.DestinationIdentifier; Debug.Assert(DestinationIdentifier.ValidText.IsAssigned); string ValidDestinationIdentifier = DestinationIdentifier.ValidText.Item; Debug.Assert(Item.ValidDestinationText.IsAssigned); Debug.Assert(Item.ValidDestinationText.Item == ValidDestinationIdentifier); if (SourceToDestinationTable.ContainsKey(ValidSourceIdentifier)) { ErrorList.AddError(new ErrorIdentifierAlreadyListed(SourceIdentifier, ValidSourceIdentifier)); Success = false; } else if (DestinationToSourceTable.ContainsKey(ValidDestinationIdentifier)) { ErrorList.AddError(new ErrorDoubleRename(Item, DestinationToSourceTable[ValidDestinationIdentifier], ValidDestinationIdentifier)); Success = false; } else { SourceToDestinationTable.Add(ValidSourceIdentifier, ValidDestinationIdentifier); DestinationToSourceTable.Add(ValidDestinationIdentifier, ValidSourceIdentifier); RenameTable.Add(SourceIdentifier, DestinationIdentifier); } } if (Success) { data = RenameTable; } 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 ResolveIdentifierList(IList <IIdentifier> identifierList, out ISealableDictionary <string, IIdentifier> resultTable) { resultTable = new SealableDictionary <string, IIdentifier>(); foreach (IIdentifier IdentifierItem in identifierList) { string ValidText = IdentifierItem.ValidText.Item; if (resultTable.ContainsKey(ValidText)) { AddSourceError(new ErrorIdentifierAlreadyListed(IdentifierItem, ValidText)); return(false); } resultTable.Add(ValidText, IdentifierItem); } return(true); }
/// <summary> /// Checks that all overloads in a list have parameters that allow them to be distinguished in a caller. /// </summary> /// <param name="overloadList">The list of overloads.</param> /// <param name="errorList">The list of errors found.</param> public static bool DisjoinedParameterCheck(IList <ICommandOverloadType> overloadList, IErrorList errorList) { ISealableDictionary <int, IList <ICommandOverloadType> > UnmixedOverloadsTable = new SealableDictionary <int, IList <ICommandOverloadType> >(); foreach (ICommandOverloadType Overload in overloadList) { int LastParameterIndex; for (LastParameterIndex = Overload.ParameterTable.Count; LastParameterIndex > 0; LastParameterIndex--) { IParameter p = Overload.ParameterTable[LastParameterIndex - 1]; IScopeAttributeFeature Attribute = p.ResolvedParameter; if (!Attribute.DefaultValue.IsAssigned) { break; } } if (!UnmixedOverloadsTable.ContainsKey(LastParameterIndex)) { UnmixedOverloadsTable.Add(LastParameterIndex, new List <ICommandOverloadType>()); } IList <ICommandOverloadType> ThisOverloadMix = UnmixedOverloadsTable[LastParameterIndex]; ThisOverloadMix.Add(Overload); } bool Success = true; foreach (KeyValuePair <int, IList <ICommandOverloadType> > Entry in UnmixedOverloadsTable) { IList <ICommandOverloadType> ThisOverloadMix = Entry.Value; for (int i = 0; i < Entry.Key; i++) { Success &= DisjoinedParameterCheck(ThisOverloadMix, i, errorList); } } return(Success); }
/// <summary> /// Apply changes in this instance to arguments. /// </summary> /// <param name="importedClassTable">The table of imported classes</param> /// <param name="exportTable">The list of exports to change.</param> /// <param name="errorList">The list of errors found.</param> public virtual bool ApplyChange(ISealableDictionary <string, IImportedClass> importedClassTable, ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > exportTable, IErrorList errorList) { if (!ExportIdentifierExists(exportTable, errorList, out IFeatureName CurrentExportName, out ISealableDictionary <string, IClass> CurrentClassTable)) { return(false); } ISealableDictionary <string, ISealableDictionary <string, IClass> > ListedExportTable = new SealableDictionary <string, ISealableDictionary <string, IClass> >(); // string (export name) -> hashtable // string (class name) -> Class ISealableDictionary <string, IClass> ListedClassTable = new SealableDictionary <string, IClass>(); // string (class name) -> Class bool InvalidExportChange = false; foreach (IIdentifier IdentifierItem in IdentifierList) { Debug.Assert(IdentifierItem.ValidText.IsAssigned); string ValidIdentifier = IdentifierItem.ValidText.Item; if (FeatureName.TableContain(exportTable, ValidIdentifier, out IFeatureName EntryName, out ISealableDictionary <string, IClass> ListedExport)) { Debug.Assert(!ListedExportTable.ContainsKey(ValidIdentifier)); ListedExportTable.Add(ValidIdentifier, ListedExport); }
/// <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); }