private static IClass ClassForTypeAny(NameGuidPair languageClass, BaseNode.CopySemantic copySpecification) { Class BaseClass = new Class(); BaseClass.CopySpecification = copySpecification; Name BaseClassName = new Name(); BaseClassName.Text = languageClass.Name; BaseClassName.ValidText.Item = languageClass.Name; BaseClass.EntityName = BaseClassName; BaseClass.ClassGuid = languageClass.Guid; BaseClass.ValidClassName = languageClass.Name; BaseClass.ClassGroupList.Seal(); BaseClass.ClassGroup.Item = new SingleClassGroup(BaseClass); BaseClass.DiscreteTable.Seal(); BaseClass.DiscreteWithValueTable.Seal(); BaseClass.FeatureTable.Seal(); BaseClass.ClassPath = $"Compiler.{CompilerPathGuid}.Language.{languageClass.Name}"; BaseClass.SetFullClassPath(); BaseClass.GenericTable.Seal(); BaseClass.InheritanceTable.Seal(); BaseClass.InheritedClassTypeTable.Seal(); BaseClass.ExportTable.Seal(); BaseClass.ConversionFromTable.Seal(); BaseClass.ConversionToTable.Seal(); BaseClass.TypedefTable.Seal(); BaseClass.ValidSourceName = string.Empty; BaseClass.ResolvedBodyTagList.Item = new List <IBody>(); BaseClass.AssignedDiscreteTable.Seal(); return(BaseClass); }
/// <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(IGeneric node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; BaseNode.CopySemantic CopyConstraint = BaseNode.CopySemantic.Any; foreach (IConstraint ConstraintItem in node.ConstraintList) { Success &= CheckConstraintConsistency(node, ConstraintItem, ref CopyConstraint); } if (node.DefaultValue.IsAssigned) { if (node.ResolvedDefaultType.Item.IsReference && CopyConstraint == BaseNode.CopySemantic.Value) { AddSourceError(new ErrorReferenceValueConstraintConformance(node, node.ResolvedDefaultType.Item, CopyConstraint)); Success = false; } if (node.ResolvedDefaultType.Item.IsValue && CopyConstraint == BaseNode.CopySemantic.Reference) { AddSourceError(new ErrorReferenceValueConstraintConformance(node, node.ResolvedDefaultType.Item, CopyConstraint)); Success = false; } } if (Success) { data = CopyConstraint; } 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(IGeneric node, object data) { node.ResolvedConformanceTable.Seal(); Debug.Assert(node.ResolvedGenericType.IsAssigned); IFormalGenericType GenericType = node.ResolvedGenericType.Item; BaseNode.CopySemantic CopyConstraint = (BaseNode.CopySemantic)data; switch (CopyConstraint) { case BaseNode.CopySemantic.Any: Debug.Assert(!GenericType.IsReference); Debug.Assert(!GenericType.IsValue); break; case BaseNode.CopySemantic.Reference: Debug.Assert(GenericType.IsReference); Debug.Assert(!GenericType.IsValue); break; case BaseNode.CopySemantic.Value: Debug.Assert(!GenericType.IsReference); Debug.Assert(GenericType.IsValue); break; } GenericType.ConformanceTable.Seal(); foreach (IConstraint Constraint in node.ConstraintList) { if (Constraint.ResolvedTypeWithRename.IsAssigned && Constraint.ResolvedTypeWithRename.Item is IClassType AsClassType) { foreach (KeyValuePair <IFeatureName, IFeatureInstance> Entry in AsClassType.FeatureTable) { Debug.Assert(!GenericType.FeatureTable.ContainsKey(Entry.Key)); GenericType.FeatureTable.Add(Entry); } } } GenericType.FeatureTable.Seal(); }
public static void ReadOnlyProperties() { ControllerTools.ResetExpectedName(); Main RootNode; IReadOnlyRootNodeIndex RootIndex0; IReadOnlyRootNodeIndex RootIndex1; RootNode = CreateRoot(ValueGuid0, Imperfections.None); Assert.That(BaseNodeHelper.NodeTreeDiagnostic.IsValid(RootNode)); RootIndex0 = new ReadOnlyRootNodeIndex(RootNode); Assert.That(RootIndex0.Node == RootNode); Assert.That(RootIndex0.IsEqual(CompareEqual.New(), RootIndex0)); RootIndex1 = new ReadOnlyRootNodeIndex(RootNode); Assert.That(RootIndex1.Node == RootNode); Assert.That(CompareEqual.CoverIsEqual(RootIndex0, RootIndex1)); ReadOnlyController Controller0 = ReadOnlyController.Create(RootIndex0); Assert.That(Controller0.RootIndex == RootIndex0); Stats Stats = Controller0.Stats; Assert.That(Stats.NodeCount >= 0); Assert.That(Stats.PlaceholderNodeCount >= 0); Assert.That(Stats.OptionalNodeCount >= 0); Assert.That(Stats.AssignedOptionalNodeCount >= 0); Assert.That(Stats.ListCount >= 0); Assert.That(Stats.BlockListCount >= 0); Assert.That(Stats.BlockCount >= 0); IReadOnlyPlaceholderNodeState RootState = Controller0.RootState; Assert.That(RootState.ParentIndex == RootIndex0); Assert.That(Controller0.Contains(RootIndex0)); Assert.That(Controller0.IndexToState(RootIndex0) == RootState); Assert.That(RootState.InnerTable.Count == 8); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.PlaceholderTree))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.PlaceholderLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.UnassignedOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.EmptyOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.AssignedOptionalTree))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.AssignedOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.LeafBlocks))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.LeafPath))); IReadOnlyPlaceholderInner MainPlaceholderTreeInner = (IReadOnlyPlaceholderInner)RootState.PropertyToInner(nameof(Main.PlaceholderTree)); Assert.That(MainPlaceholderTreeInner != null); if (MainPlaceholderTreeInner != null) { Assert.That(MainPlaceholderTreeInner.InterfaceType.IsTypeof <Tree>()); Assert.That(MainPlaceholderTreeInner.ChildState != null); Assert.That(MainPlaceholderTreeInner.ChildState?.ParentInner == MainPlaceholderTreeInner); } IReadOnlyPlaceholderInner MainPlaceholderLeafInner = (IReadOnlyPlaceholderInner)RootState.PropertyToInner(nameof(Main.PlaceholderLeaf)); Assert.That(MainPlaceholderLeafInner != null); if (MainPlaceholderLeafInner != null) { Assert.That(MainPlaceholderLeafInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainPlaceholderLeafInner.ChildState != null); Assert.That(MainPlaceholderLeafInner.ChildState?.ParentInner == MainPlaceholderLeafInner); } IReadOnlyOptionalInner MainUnassignedOptionalInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.UnassignedOptionalLeaf)); Assert.That(MainUnassignedOptionalInner != null); if (MainUnassignedOptionalInner != null) { Assert.That(MainUnassignedOptionalInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(!MainUnassignedOptionalInner.IsAssigned); Assert.That(MainUnassignedOptionalInner.ChildState != null); Assert.That(MainUnassignedOptionalInner.ChildState?.ParentInner == MainUnassignedOptionalInner); } IReadOnlyOptionalInner MainAssignedOptionalTreeInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.AssignedOptionalTree)); Assert.That(MainAssignedOptionalTreeInner != null); if (MainAssignedOptionalTreeInner != null) { Assert.That(MainAssignedOptionalTreeInner.InterfaceType.IsTypeof <Tree>()); Assert.That(MainAssignedOptionalTreeInner.IsAssigned); } IReadOnlyNodeState AssignedOptionalTreeState = MainAssignedOptionalTreeInner.ChildState; Assert.That(AssignedOptionalTreeState != null); if (AssignedOptionalTreeState != null) { Assert.That(AssignedOptionalTreeState.ParentInner == MainAssignedOptionalTreeInner); Assert.That(AssignedOptionalTreeState.ParentState == RootState); } ReadOnlyNodeStateReadOnlyList AssignedOptionalTreeAllChildren = AssignedOptionalTreeState.GetAllChildren(); Assert.That(AssignedOptionalTreeAllChildren.Count == 2, $"New count: {AssignedOptionalTreeAllChildren.Count}"); IReadOnlyOptionalInner MainAssignedOptionalLeafInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.AssignedOptionalLeaf)); Assert.That(MainAssignedOptionalLeafInner != null); if (MainAssignedOptionalLeafInner != null) { Assert.That(MainAssignedOptionalLeafInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainAssignedOptionalLeafInner.IsAssigned); Assert.That(MainAssignedOptionalLeafInner.ChildState != null); Assert.That(MainAssignedOptionalLeafInner.ChildState.ParentInner == MainAssignedOptionalLeafInner); } IReadOnlyBlockListInner MainLeafBlocksInner = (IReadOnlyBlockListInner)RootState.PropertyToInner(nameof(Main.LeafBlocks)); Assert.That(MainLeafBlocksInner != null); if (MainLeafBlocksInner != null) { Assert.That(!MainLeafBlocksInner.IsNeverEmpty); Assert.That(!MainLeafBlocksInner.IsEmpty); Assert.That(!MainLeafBlocksInner.IsSingle); Assert.That(MainLeafBlocksInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainLeafBlocksInner.BlockType.IsTypeof <BaseNode.IBlock <Leaf> >()); Assert.That(MainLeafBlocksInner.ItemType.IsTypeof <Leaf>()); Assert.That(MainLeafBlocksInner.Count == 4); Assert.That(MainLeafBlocksInner.BlockStateList != null); Assert.That(MainLeafBlocksInner.BlockStateList.Count == 3); Assert.That(MainLeafBlocksInner.AllIndexes().Count == MainLeafBlocksInner.Count); } IReadOnlyBlockState LeafBlock = MainLeafBlocksInner.BlockStateList[0]; Assert.That(LeafBlock != null); if (LeafBlock != null) { Assert.That(LeafBlock.StateList != null); Assert.That(LeafBlock.StateList.Count == 1); Assert.That(MainLeafBlocksInner.FirstNodeState == LeafBlock.StateList[0]); Assert.That(MainLeafBlocksInner.IndexAt(0, 0) == MainLeafBlocksInner.FirstNodeState.ParentIndex); Assert.That(LeafBlock.Comment == ""); } IReadOnlyPlaceholderInner PatternInner = (IReadOnlyPlaceholderInner)LeafBlock.PropertyToInner(nameof(BaseNode.IBlock.ReplicationPattern)); Assert.That(PatternInner != null); IReadOnlyPlaceholderInner SourceInner = (IReadOnlyPlaceholderInner)LeafBlock.PropertyToInner(nameof(BaseNode.IBlock.SourceIdentifier)); Assert.That(SourceInner != null); IReadOnlyPatternState PatternState = LeafBlock.PatternState; Assert.That(PatternState != null); if (PatternState != null) { Assert.That(PatternState.ParentInner == PatternInner); Assert.That(PatternState.ParentIndex == LeafBlock.PatternIndex); } IReadOnlySourceState SourceState = LeafBlock.SourceState; Assert.That(SourceState != null); if (SourceState != null) { Assert.That(SourceState.ParentInner == SourceInner); Assert.That(SourceState.ParentIndex == LeafBlock.SourceIndex); } Assert.That(MainLeafBlocksInner.FirstNodeState == LeafBlock.StateList[0]); IReadOnlyListInner MainLeafPathInner = (IReadOnlyListInner)RootState.PropertyToInner(nameof(Main.LeafPath)); Assert.That(MainLeafPathInner != null); if (MainLeafPathInner != null) { Assert.That(!MainLeafPathInner.IsNeverEmpty); Assert.That(MainLeafPathInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainLeafPathInner.Count == 2); Assert.That(MainLeafPathInner.StateList != null); Assert.That(MainLeafPathInner.StateList?.Count == 2); Assert.That(MainLeafPathInner.FirstNodeState == MainLeafPathInner.StateList[0]); Assert.That(MainLeafPathInner.IndexAt(0) == MainLeafPathInner.FirstNodeState.ParentIndex); Assert.That(MainLeafPathInner.AllIndexes().Count == MainLeafPathInner.Count); } ReadOnlyNodeStateReadOnlyList AllChildren = RootState.GetAllChildren(); Assert.That(AllChildren.Count == 19, $"New count: {AllChildren.Count}"); IReadOnlyPlaceholderInner PlaceholderInner = (IReadOnlyPlaceholderInner)RootState.InnerTable[nameof(Main.PlaceholderLeaf)]; Assert.That(PlaceholderInner != null); IReadOnlyBrowsingPlaceholderNodeIndex PlaceholderNodeIndex = (IReadOnlyBrowsingPlaceholderNodeIndex)PlaceholderInner.ChildState.ParentIndex; Assert.That(PlaceholderNodeIndex != null); Assert.That(Controller0.Contains(PlaceholderNodeIndex)); IReadOnlyOptionalInner UnassignedOptionalInner = (IReadOnlyOptionalInner)RootState.InnerTable[nameof(Main.UnassignedOptionalLeaf)]; Assert.That(UnassignedOptionalInner != null); IReadOnlyBrowsingOptionalNodeIndex UnassignedOptionalNodeIndex = UnassignedOptionalInner.ChildState.ParentIndex; Assert.That(UnassignedOptionalNodeIndex != null); Assert.That(Controller0.Contains(UnassignedOptionalNodeIndex)); Assert.That(Controller0.IsAssigned(UnassignedOptionalNodeIndex) == false); IReadOnlyOptionalInner AssignedOptionalInner = (IReadOnlyOptionalInner)RootState.InnerTable[nameof(Main.AssignedOptionalLeaf)]; Assert.That(AssignedOptionalInner != null); IReadOnlyBrowsingOptionalNodeIndex AssignedOptionalNodeIndex = AssignedOptionalInner.ChildState.ParentIndex; Assert.That(AssignedOptionalNodeIndex != null); Assert.That(Controller0.Contains(AssignedOptionalNodeIndex)); Assert.That(Controller0.IsAssigned(AssignedOptionalNodeIndex) == true); int Min, Max; object ReadValue; RootState.PropertyToValue(nameof(Main.ValueBoolean), out ReadValue, out Min, out Max); bool ReadAsBoolean = ((int)ReadValue) != 0; Assert.That(ReadAsBoolean == true); Assert.That(Controller0.GetDiscreteValue(RootIndex0, nameof(Main.ValueBoolean), out Min, out Max) == (ReadAsBoolean ? 1 : 0)); Assert.That(Min == 0); Assert.That(Max == 1); RootState.PropertyToValue(nameof(Main.ValueEnum), out ReadValue, out Min, out Max); BaseNode.CopySemantic ReadAsEnum = (BaseNode.CopySemantic)(int) ReadValue; Assert.That(ReadAsEnum == BaseNode.CopySemantic.Value); Assert.That(Controller0.GetDiscreteValue(RootIndex0, nameof(Main.ValueEnum), out Min, out Max) == (int)ReadAsEnum); Assert.That(Min == 0); Assert.That(Max == 2); RootState.PropertyToValue(nameof(Main.ValueString), out ReadValue, out Min, out Max); string ReadAsString = ReadValue as string; Assert.That(ReadAsString == "s"); Assert.That(Controller0.GetStringValue(RootIndex0, nameof(Main.ValueString)) == ReadAsString); RootState.PropertyToValue(nameof(Main.ValueGuid), out ReadValue, out Min, out Max); Guid ReadAsGuid = (Guid)ReadValue; Assert.That(ReadAsGuid == ValueGuid0); Assert.That(Controller0.GetGuidValue(RootIndex0, nameof(Main.ValueGuid)) == ReadAsGuid); ReadOnlyController Controller1 = ReadOnlyController.Create(RootIndex0); Assert.That(Controller0.IsEqual(CompareEqual.New(), Controller0)); Assert.That(CompareEqual.CoverIsEqual(Controller0, Controller1)); }
private bool CheckConstraintConsistency(IGeneric node, IConstraint constraintItem, ref BaseNode.CopySemantic copyConstraint) { bool Success = true; ITypeName BaseTypeName = constraintItem.ResolvedParentTypeName.Item; ICompiledType BaseType = constraintItem.ResolvedParentType.Item; if (node.DefaultValue.IsAssigned && !ObjectType.TypeConformToBase(node.ResolvedDefaultType.Item, BaseType, ErrorList, (IObjectType)node.DefaultValue.Item, isConversionAllowed: false)) { Success = false; } if (copyConstraint == BaseNode.CopySemantic.Reference) { if (BaseType.IsValue) { AddSourceError(new ErrorReferenceValueConstraintConformance(node, node.ResolvedDefaultType.Item, copyConstraint)); Success = false; } } else if (copyConstraint == BaseNode.CopySemantic.Value) { if (BaseType.IsReference) { AddSourceError(new ErrorReferenceValueConstraintConformance(node, node.ResolvedDefaultType.Item, copyConstraint)); Success = false; } } else { if (BaseType.IsReference) { copyConstraint = BaseNode.CopySemantic.Reference; } else if (BaseType.IsValue) { copyConstraint = BaseNode.CopySemantic.Value; } } return(Success); }
/// <summary> /// Initializes a new instance of the <see cref="ErrorReferenceValueConstraintConformance"/> class. /// </summary> /// <param name="source">The error location.</param> /// <param name="derivedType">The derived type</param> /// <param name="constraint">The constraint.</param> public ErrorReferenceValueConstraintConformance(ISource source, ICompiledType derivedType, BaseNode.CopySemantic constraint) : base(source) { DerivedType = derivedType; Constraint = constraint; }