/// <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(IDiscrete node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; IClass EmbeddingClass = node.EmbeddingClass; IName EntityName = (IName)node.EntityName; string ValidText = EntityName.ValidText.Item; IFeatureName Key; if (FeatureName.TableContain(EmbeddingClass.LocalExportTable, ValidText, out Key, out ISealableDictionary <string, IClass> ExportTable)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalTypedefTable, ValidText, out Key, out ITypedefType TypedefType)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalDiscreteTable, ValidText, out Key, out IDiscrete Discrete)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalFeatureTable, ValidText, out Key, out IFeatureInstance FeatureInstance)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } 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(ITypedef node, object data) { IObjectType DefinedTypeItem = (IObjectType)node.DefinedType; ITypeName DefinedTypeName = DefinedTypeItem.ResolvedTypeName.Item; ICompiledType DefinedType = DefinedTypeItem.ResolvedType.Item; node.ResolvedDefinedTypeName.Item = DefinedTypeName; node.ResolvedDefinedType.Item = DefinedType; if (!DefinedType.OriginatingTypedef.IsAssigned) { DefinedType.OriginatingTypedef.Item = node; } IName EntityName = (IName)node.EntityName; IClass EmbeddingClass = node.EmbeddingClass; Debug.Assert(EntityName.ValidText.IsAssigned); string ValidText = EntityName.ValidText.Item; bool IsFound = FeatureName.TableContain(EmbeddingClass.LocalTypedefTable, ValidText, out IFeatureName Key, out ITypedefType ResolvedTypedefType); Debug.Assert(IsFound && ResolvedTypedefType != null); ResolvedTypedefType.ReferencedTypeName.Item = DefinedTypeName; ResolvedTypedefType.ReferencedType.Item = DefinedType; #if COVERAGE string TypeString = ResolvedTypedefType.ToString(); #endif }
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> /// Gets the export status of a feature in the class that implements it. /// </summary> /// <param name="sourceClass">The class implementing the feature.</param> public virtual CSharpExports GetExportStatus(ICSharpClass sourceClass) { bool IsExportedToClient; IFeature AsFeature = Source as IFeature; Debug.Assert(AsFeature != null); IIdentifier Identifier = (IIdentifier)AsFeature.ExportIdentifier; string ExportIdentifier = Identifier.ValidText.Item; if (ExportIdentifier == "All") { IsExportedToClient = true; } else if (ExportIdentifier == "None" || ExportIdentifier == "Self") { IsExportedToClient = false; } else { FeatureName.TableContain(Owner.Source.ExportTable, ExportIdentifier, out IFeatureName ExportName, out ISealableDictionary <string, IClass> ExportList); Debug.Assert(ExportList.Count > 0); if (ExportList.Count > 1) { IsExportedToClient = true; } else { if (ExportList.ContainsKey(sourceClass.ValidClassName)) { IsExportedToClient = false; // Export to self = self + descendant = protected } else { IsExportedToClient = true; // export to another = export to all = public } } } if (IsExportedToClient) { return(CSharpExports.Public); } else if (AsFeature.Export == BaseNode.ExportStatus.Exported) { return(CSharpExports.Protected); } else { return(CSharpExports.Private); } }
private static CSharpExports GetExportStatus(IFeatureName name, IClass sourceClass, ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > exportTable, IFeature sourceFeature) { bool IsExportedToClient; string FeatureExport = sourceFeature.ExportIdentifier.Text; if (FeatureExport == "All") { IsExportedToClient = true; } else if (FeatureExport == "None" || FeatureExport == "Self") { IsExportedToClient = false; } else { bool IsExported = FeatureName.TableContain(exportTable, FeatureExport, out IFeatureName ExportName, out ISealableDictionary <string, IClass> ExportList); Debug.Assert(IsExported); Debug.Assert(ExportList.Count > 0); if (ExportList.Count > 1) { IsExportedToClient = true; } else { if (ExportList.ContainsKey(sourceClass.ValidClassName)) { IsExportedToClient = false; // Export to self = self + descendant = protected } else { IsExportedToClient = true; // export to another = export to all = public } } } if (IsExportedToClient) { return(CSharpExports.Public); } else if (sourceFeature.Export == BaseNode.ExportStatus.Exported) { return(CSharpExports.Protected); } else { return(CSharpExports.Private); } }
/// <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(IRaiseEventInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data) { data = null; bool Success = true; IIdentifier QueryIdentifier = (IIdentifier)node.QueryIdentifier; string ValidText = QueryIdentifier.ValidText.Item; IClass EmbeddingClass = node.EmbeddingClass; IClassType BaseType = EmbeddingClass.ResolvedClassType.Item; if (!FeatureName.TableContain(EmbeddingClass.FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance)) { AddSourceError(new ErrorUnknownIdentifier(QueryIdentifier, ValidText)); Success = false; }
/// <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(IExport node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; IClass EmbeddingClass = node.EmbeddingClass; IName EntityName = (IName)node.EntityName; Debug.Assert(EntityName.ValidText.IsAssigned); string ValidText = EntityName.ValidText.Item; IFeatureName Key; if (EmbeddingClass.ImportedClassTable.ContainsKey(ValidText)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalExportTable, ValidText, out Key, out ISealableDictionary <string, IClass> ExportTable)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalTypedefTable, ValidText, out Key, out ITypedefType TypedefType)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalDiscreteTable, ValidText, out Key, out IDiscrete Discrete)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalFeatureTable, ValidText, out Key, out IFeatureInstance FeatureInstance)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } // Ensured since the root is valid. Debug.Assert(node.ClassIdentifierList.Count > 0); return(Success); }
/// <summary> /// Checks if an intermediate step in a path to a target type is resolved. /// </summary> /// <param name="item">The current step.</param> /// <param name="nextItem">The step after <paramref name="item"/>.</param> /// <param name="localEntityList">The list of available local variables.</param> /// <param name="featureTable">The feature table to use.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="isInterrupted">Set if an error is found.</param> /// <returns>False to stop; True to continue with the next step.</returns> public static bool IsPathItemReady(IIdentifier item, IIdentifier nextItem, ref List <IEntityDeclaration> localEntityList, ref ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, IErrorList errorList, ref bool isInterrupted) { Debug.Assert(featureTable.IsSealed); Debug.Assert(item.ValidText.IsAssigned); string Text = item.ValidText.Item; bool IsLocal = IsLocalEntity(Text, localEntityList, out IEntityDeclaration Entity); bool IsFeature = FeatureName.TableContain(featureTable, Text, out IFeatureName ItemName, out IFeatureInstance ItemInstance); // Check that the name is known in the table of features for the current step. if (!IsLocal && !IsFeature) { errorList.AddError(new ErrorUnknownIdentifier(item, Text)); isInterrupted = true; return(false); } bool IsReady = false; ICompiledType ItemType = null; if (IsLocal) { IsReady = Entity.ValidEntity.IsAssigned && Entity.ValidEntity.Item.ResolvedEffectiveType.IsAssigned; ItemType = IsReady ? Entity.ValidEntity.Item.ResolvedEffectiveType.Item : null; } else { ICompiledFeature ItemFeature = ItemInstance.Feature; IsReady = IsPathGlobalItemReady(ItemFeature, nextItem, errorList, ref isInterrupted, out ItemType); } if (IsReady) { Debug.Assert(ItemType != null); featureTable = ItemType.FeatureTable; IsReady = featureTable.IsSealed; } return(IsReady); }
/// <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(IClass node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; IList <IIdentifier> ConversionList = node.ConversionList; ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = node.FeatureTable; ISealableDictionary <IFeatureName, ICreationFeature> ConversionFromTable = new SealableDictionary <IFeatureName, ICreationFeature>(); ISealableDictionary <IFeatureName, IFunctionFeature> ConversionToTable = new SealableDictionary <IFeatureName, IFunctionFeature>(); foreach (IIdentifier Identifier in ConversionList) { Debug.Assert(Identifier.ValidText.IsAssigned); string ValidText = Identifier.ValidText.Item; if (!FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance)) { AddSourceError(new ErrorUnknownIdentifier(Identifier, ValidText)); Success = false; }
private static bool CheckRename(ICSharpClass cSharpClass, IErrorList errorList) { bool Result = true; foreach (IInheritance InheritanceItem in cSharpClass.Source.InheritanceList) { IClassType ParentType = InheritanceItem.ResolvedClassParentType.Item; IClass ParentClass = ParentType.BaseClass; bool BadRename = false; foreach (IRename RenameItem in InheritanceItem.RenameList) { string ValidSourceText = RenameItem.ValidSourceText.Item; if (!FeatureName.TableContain(ParentClass.FeatureTable, ValidSourceText, out IFeatureName Key, out IFeatureInstance Instance)) { BadRename = true; break; } IClass SourceClass = Instance.Owner; ICompiledFeature SourceFeature = Instance.Feature; CSharpExports ExportStatus = GetExportStatus(Key, SourceClass, cSharpClass.Source.ExportTable, (IFeature)SourceFeature); if (ExportStatus == CSharpExports.Public && !(SourceFeature is ICreationFeature)) { BadRename = true; break; } } if (BadRename) { errorList.AddError(new ErrorInvalidRename(InheritanceItem)); } Result &= !BadRename; } return(Result); }
private bool GetCreatedEntity(ICreateInstruction node, out ITypeName attributeTypeName, out ICompiledType attributeType) { attributeTypeName = null; attributeType = null; bool Success = false; IIdentifier EntityIdentifier = (IIdentifier)node.EntityIdentifier; string ValidText = EntityIdentifier.ValidText.Item; IClass EmbeddingClass = node.EmbeddingClass; IClassType BaseType = EmbeddingClass.ResolvedClassType.Item; ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node); if (LocalScope.ContainsKey(ValidText)) { IScopeAttributeFeature CreatedFeature = LocalScope[ValidText]; attributeTypeName = CreatedFeature.ResolvedEffectiveTypeName.Item; attributeType = CreatedFeature.ResolvedEffectiveType.Item; Success = true; } else if (FeatureName.TableContain(EmbeddingClass.FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance)) { if (Instance.Feature is IAttributeFeature AsAttributeFeature) { attributeTypeName = AsAttributeFeature.ResolvedEntityTypeName.Item; attributeType = AsAttributeFeature.ResolvedEntityType.Item; Success = true; } else if (Instance.Feature is IPropertyFeature AsPropertyFeature) { attributeTypeName = AsPropertyFeature.ResolvedEntityTypeName.Item; attributeType = AsPropertyFeature.ResolvedEntityType.Item; Success = true; } else { AddSourceError(new ErrorCreatedFeatureNotAttributeOrProperty(EntityIdentifier, ValidText)); } }
/// <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(ITypedef node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; IClass EmbeddingClass = node.EmbeddingClass; IName EntityName = (IName)node.EntityName; IFeatureName Key; Debug.Assert(EntityName.ValidText.IsAssigned); string ValidText = EntityName.ValidText.Item; if (EmbeddingClass.ImportedClassTable.ContainsKey(ValidText)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (EmbeddingClass.LocalGenericTable.ContainsKey(ValidText)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalExportTable, ValidText, out Key, out ISealableDictionary <string, IClass> Export)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else if (FeatureName.TableContain(EmbeddingClass.LocalTypedefTable, ValidText, out Key, out ITypedefType TypedefType)) { AddSourceError(new ErrorDuplicateName(EntityName, ValidText)); Success = false; } else { // This is checked in the corresponding step of a discrete rule. bool IsDiscreteName = FeatureName.TableContain(EmbeddingClass.LocalDiscreteTable, ValidText, out Key, out IDiscrete Discrete); Debug.Assert(!IsDiscreteName); // This is checked in the corresponding step of a feature rule. bool IsFeatureName = FeatureName.TableContain(EmbeddingClass.LocalFeatureTable, ValidText, out Key, out IFeatureInstance Feature); Debug.Assert(!IsFeatureName); } if (node.DefinedType is IAnchoredType AsAnchoredType) { AddSourceError(new ErrorInvalidAnchoredType(AsAnchoredType)); Success = false; } else if (node.DefinedType is IKeywordAnchoredType AsKeywordAnchoredType) { bool IsAllowed; switch (AsKeywordAnchoredType.Anchor) { case BaseNode.Keyword.True: case BaseNode.Keyword.False: case BaseNode.Keyword.Retry: case BaseNode.Keyword.Exception: IsAllowed = true; break; default: IsAllowed = false; break; } if (!IsAllowed) { AddSourceError(new ErrorInvalidAnchoredType(AsKeywordAnchoredType)); Success = false; } } 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(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); }
/// <summary> /// Checks if the last step in a path to a target type is resolved. /// </summary> /// <param name="item">The last step.</param> /// <param name="localEntityList">The list of available local variables.</param> /// <param name="featureTable">The feature table to use.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="isInterrupted">Set if an error is found.</param> /// <param name="resolvedPathTypeName">The target type name upon return.</param> /// <param name="resolvedPathType">The target type upon return.</param> /// <returns>True if the path step could be resolved, or an error was found.</returns> public static bool IsLastPathItemReady(IIdentifier item, List <IEntityDeclaration> localEntityList, ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, IErrorList errorList, ref bool isInterrupted, out ITypeName resolvedPathTypeName, out ICompiledType resolvedPathType) { Debug.Assert(featureTable.IsSealed); Debug.Assert(item.ValidText.IsAssigned); resolvedPathTypeName = null; resolvedPathType = null; string Text = item.ValidText.Item; bool IsLocal = IsLocalEntity(Text, localEntityList, out IEntityDeclaration Entity); bool IsFeature = FeatureName.TableContain(featureTable, Text, out IFeatureName ItemName, out IFeatureInstance ItemInstance); // Check that the name is known in the table of features for the current step. if (!IsLocal && !IsFeature) { errorList.AddError(new ErrorUnknownIdentifier(item, Text)); isInterrupted = true; return(false); } bool Result = false; if (IsLocal) { if (Entity.ValidEntity.IsAssigned && Entity.ValidEntity.Item.ResolvedEffectiveType.IsAssigned) { resolvedPathTypeName = Entity.ValidEntity.Item.ResolvedEffectiveTypeName.Item; resolvedPathType = Entity.ValidEntity.Item.ResolvedEffectiveType.Item; Result = true; } } else { ICompiledFeature ItemFeature = ItemInstance.Feature; bool IsHandled = false; switch (ItemFeature) { case IAttributeFeature AsAttributeFeature: Result = IsAttributeFeatureReady(AsAttributeFeature, out resolvedPathTypeName, out resolvedPathType); IsHandled = true; break; case IConstantFeature AsConstantFeature: Result = IsConstantFeatureReady(AsConstantFeature, out resolvedPathTypeName, out resolvedPathType); IsHandled = true; break; case ICreationFeature AsCreationFeature: case IProcedureFeature AsProcedureFeature: errorList.AddError(new ErrorNotAnchor(item, Text)); isInterrupted = true; return(false); case IFunctionFeature AsFunctionFeature: Result = IsFunctionFeatureReady(AsFunctionFeature, out resolvedPathTypeName, out resolvedPathType); IsHandled = true; break; case IPropertyFeature AsPropertyFeature: Result = IsPropertyFeatureReady(AsPropertyFeature, out resolvedPathTypeName, out resolvedPathType); IsHandled = true; break; case IIndexerFeature AsIndexerFeature: Result = IsIndexerFeatureReady(AsIndexerFeature, out resolvedPathTypeName, out resolvedPathType); IsHandled = true; break; } Debug.Assert(IsHandled); } return(Result); }
private bool IsTypeReady(ISimpleType node, out object data) { data = null; bool IsReady = true; ITypeName ValidTypeName = null; ICompiledType ValidType = null; IError Error = null; IClass EmbeddingClass = node.EmbeddingClass; IFeature EmbeddingFeature = node.EmbeddingFeature; IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier; Debug.Assert(ClassIdentifier.ValidText.IsAssigned); string ValidIdentifier = ClassIdentifier.ValidText.Item; ISealableDictionary <string, IImportedClass> ImportedClassTable = EmbeddingClass.ImportedClassTable; ISealableDictionary <string, ICompiledType> LocalGenericTable = EmbeddingClass.LocalGenericTable; ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > LocalExportTable = EmbeddingClass.LocalExportTable; ISealableDictionary <IFeatureName, ITypedefType> LocalTypedefTable = EmbeddingClass.LocalTypedefTable; ISealableDictionary <IFeatureName, IDiscrete> LocalDiscreteTable = EmbeddingClass.LocalDiscreteTable; ISealableDictionary <IFeatureName, IFeatureInstance> LocalFeatureTable = EmbeddingClass.LocalFeatureTable; IsReady &= ImportedClassTable.IsSealed; IsReady &= LocalGenericTable.IsSealed; IsReady &= LocalExportTable.IsSealed; IsReady &= LocalTypedefTable.IsSealed; IsReady &= LocalDiscreteTable.IsSealed; IsReady &= LocalFeatureTable.IsSealed; IsReady &= EmbeddingClass.ResolvedClassType.IsAssigned; if (IsReady) { if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.Any.Name.ToUpperInvariant()) { GetBaseClassType(Class.ClassAny, out ValidTypeName, out ValidType); } else if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.AnyReference.Name.ToUpperInvariant()) { GetBaseClassType(Class.ClassAnyReference, out ValidTypeName, out ValidType); } else if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.AnyValue.Name.ToUpperInvariant()) { GetBaseClassType(Class.ClassAnyValue, out ValidTypeName, out ValidType); } else if (ImportedClassTable.ContainsKey(ValidIdentifier)) { IImportedClass Imported = ImportedClassTable[ValidIdentifier]; IClass BaseClass = Imported.Item; IsReady = CheckValidityAsClass(BaseClass, out ValidTypeName, out ValidType, out bool IsInvalidGeneric); if (IsInvalidGeneric) { Error = new ErrorGenericClass(ClassIdentifier, ValidIdentifier); } } else if (LocalGenericTable.ContainsKey(ValidIdentifier)) { IFormalGenericType FormalGeneric = (IFormalGenericType)LocalGenericTable[ValidIdentifier]; GetGenericType(FormalGeneric, out ValidTypeName, out ValidType); } else if (FeatureName.TableContain(LocalTypedefTable, ValidIdentifier, out IFeatureName Key, out ITypedefType DefinedType)) { IsReady = CheckValidityAsTypedef(DefinedType, out ValidTypeName, out ValidType); } else { Error = new ErrorUnknownIdentifier(ClassIdentifier, ValidIdentifier); } }