private bool ResolveFeatureInstancingList(ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, ISealableDictionary <string, IIdentifier> identifierTable, Action <IFeatureInstance> handler) { foreach (KeyValuePair <string, IIdentifier> IdentifierEntry in identifierTable) { string ValidIdentifier = IdentifierEntry.Key; IIdentifier IdentifierItem = IdentifierEntry.Value; OnceReference <IFeatureInstance> CurrentInstance = new OnceReference <IFeatureInstance>(); foreach (KeyValuePair <IFeatureName, IFeatureInstance> Entry in featureTable) { IFeatureName EntryName = Entry.Key; if (EntryName.Name == ValidIdentifier) { CurrentInstance.Item = Entry.Value; break; } } if (!CurrentInstance.IsAssigned) { AddSourceError(new ErrorUnknownIdentifier(IdentifierItem, ValidIdentifier)); return(false); } handler(CurrentInstance.Item); } return(true); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { ResolvedResult = new OnceReference <IResultType>(); ConstantSourceList = new SealableList <IExpression>(); ExpressionConstant = new OnceReference <ILanguageConstant>(); ResolvedPrecursor = new OnceReference <IFeatureInstance>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedException = new OnceReference <IResultException>(); ResolvedIndexer = new OnceReference <IIndexerFeature>(); FeatureCall = new OnceReference <IFeatureCall>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { ResolvedTagTable = new SealableDictionary <string, IExpression>(); ResolvedResult = new OnceReference <IResultType>(); ResolvedRequireList = new OnceReference <IList <IAssertion> >(); ResolvedEnsureList = new OnceReference <IList <IAssertion> >(); ResolvedExceptionIdentifierList = new OnceReference <IList <IIdentifier> >(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedInstructionList = new OnceReference <IList <IInstruction> >(); IsHandled = true; } Debug.Assert(IsHandled); }
public InheritedInstanceInfo() { EffectiveInstance = new OnceReference <InstanceNameInfo>(); PrecursorInstanceList = new List <InstanceNameInfo>(); IsKept = false; IsDiscontinued = false; }
/// <summary> /// Checks if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { IList ItemList = GetSourceObject(node, out bool IsInterrupted); IList <TValue> ReadyValueList = new List <TValue>(); for (int i = 0; i < ItemList.Count && !IsInterrupted; i++) { TItem Item = (TItem)ItemList[i]; OnceReference <TValue> Reference = ItemProperty.GetValue(Item) as OnceReference <TValue>; Debug.Assert(Reference != null); if (Reference.IsAssigned) { ReadyValueList.Add(Reference.Item); } else { IsInterrupted = true; } } if (IsInterrupted) { data = null; return(false); } else { data = ReadyValueList; return(true); } }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { ResolvedResult = new OnceReference <IResultType>(); ConstantSourceList = new SealableList <IExpression>(); ExpressionConstant = new OnceReference <ILanguageConstant>(); ResolvedFinalFeature = new OnceReference <ICompiledFeature>(); ResolvedFinalDiscrete = new OnceReference <IDiscrete>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedException = new OnceReference <IResultException>(); SelectedResultList = new SealableList <IParameter>(); SelectedOverload = new OnceReference <IQueryOverload>(); SelectedOverloadType = new OnceReference <IQueryOverloadType>(); FeatureCall = new OnceReference <IFeatureCall>(); InheritBySideAttribute = false; IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedAgentTypeName = new OnceReference <ITypeName>(); ResolvedAgentType = new OnceReference <ICompiledType>(); ResolvedEffectiveTypeName = new OnceReference <ITypeName>(); ResolvedEffectiveType = new OnceReference <ICompiledType>(); ValidFeatureName = new OnceReference <IFeatureName>(); ResolvedFeature = new OnceReference <ICompiledFeature>(); MostCommonResult = new OnceReference <IExpressionType>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { IsCallingPrecursor = false; IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Merges two lists of exceptions if they are available. /// </summary> /// <param name="mergedResult">The list of exceptions to update.</param> /// <param name="other">The optional list of exceptions to merge.</param> public static void Merge(IResultException mergedResult, OnceReference <IResultException> other) { if (other.IsAssigned) { Merge(mergedResult, other.Item); } }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { ResolvedResult = new OnceReference <IResultType>(); ConstantSourceList = new SealableList <IExpression>(); ExpressionConstant = new OnceReference <ILanguageConstant>(); ResolvedAgentTypeName = new OnceReference <ITypeName>(); ResolvedAgentType = new OnceReference <ICompiledType>(); ResolvedFeature = new OnceReference <ICompiledFeature>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedException = new OnceReference <IResultException>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { LocalScope = new SealableDictionary <string, IScopeAttributeFeature>(); InnerScopes = new List <IScopeHolder>(); FullScope = new SealableDictionary <string, IScopeAttributeFeature>(); ParameterTable = new SealableList <IParameter>(); ResolvedAssociatedType = new OnceReference <ICommandOverloadType>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { AdditionalScope = new SealableDictionary <string, IScopeAttributeFeature>(); AdditionalScope.Seal(); ResolvedBody = new OnceReference <ICompiledBody>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Checks if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { data = null; bool Result = false; IOptionalReference OptionalValue = GetSourceObject(node, out bool IsInterrupted); if (!IsInterrupted) { if (OptionalValue.IsAssigned) { TRef Value = (TRef)OptionalValue.Item; OnceReference <TValue> Reference = ItemProperty.GetValue(Value) as OnceReference <TValue>; Debug.Assert(Reference != null); if (Reference.IsAssigned) { data = Reference.Item; Result = true; } } else { Result = true; } } return(Result); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { LocalScope = new SealableDictionary <string, IScopeAttributeFeature>(); InnerScopes = new List <IScopeHolder>(); FullScope = new SealableDictionary <string, IScopeAttributeFeature>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { AdditionalScope = new SealableDictionary <string, IScopeAttributeFeature>(); AdditionalScope.Seal(); ResolvedTagTable = new SealableDictionary <string, IExpression>(); ResolvedResult = new OnceReference <IResultType>(); ResolvedRequireList = new OnceReference <IList <IAssertion> >(); ResolvedEnsureList = new OnceReference <IList <IAssertion> >(); ResolvedExceptionIdentifierList = new OnceReference <IList <IIdentifier> >(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedInstructionList = new OnceReference <IList <IInstruction> >(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { InnerLoopScope = new SealableDictionary <string, IScopeAttributeFeature>(); LocalScope = new SealableDictionary <string, IScopeAttributeFeature>(); InnerScopes = new List <IScopeHolder>(); FullScope = new SealableDictionary <string, IScopeAttributeFeature>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { AdditionalScope = new SealableDictionary <string, IScopeAttributeFeature>(); // Don't seal it yet, not until indexers are handled. ResolvedResult = new OnceReference <IResultType>(); ResolvedInitResult = new OnceReference <IResultType>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedException = new OnceReference <IResultException>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { LocalScope = new SealableDictionary <string, IScopeAttributeFeature>(); InnerScopes = new List <IScopeHolder>(); FullScope = new SealableDictionary <string, IScopeAttributeFeature>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { AdditionalScope = new SealableDictionary <string, IScopeAttributeFeature>(); AdditionalScope.Seal(); ResolvedResult = new OnceReference <IResultType>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedType = new OnceReference <ICompiledType>(); ResolvedException = new OnceReference <IResultException>(); FeatureCall = new OnceReference <IFeatureCall>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedAgentTypeName = new OnceReference <ITypeName>(); ResolvedAgentType = new OnceReference <ICompiledType>(); ResolvedEffectiveTypeName = new OnceReference <ITypeName>(); ResolvedEffectiveType = new OnceReference <ICompiledType>(); ValidFeatureName = new OnceReference <IFeatureName>(); ResolvedFeature = new OnceReference <ICompiledFeature>(); ResolvedEntityTypeName = new OnceReference <ITypeName>(); ResolvedEntityType = new OnceReference <ICompiledType>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedEventType = (BaseNode.EventType)(-1); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedBaseTypeName = new OnceReference <ITypeName>(); ResolvedBaseType = new OnceReference <IClassType>(); ResolvedEntityTypeName = new OnceReference <ITypeName>(); ResolvedEntityType = new OnceReference <ICompiledType>(); ParameterTable = new SealableList <IParameter>(); ResolvedTypeName = new OnceReference <ITypeName>(); ResolvedType = new OnceReference <ICompiledType>(); DiscreteTable = new SealableDictionary <IFeatureName, IDiscrete>(); FeatureTable = new SealableDictionary <IFeatureName, IFeatureInstance>(); ExportTable = new SealableDictionary <IFeatureName, ISealableDictionary <string, IClass> >(); ConformanceTable = new SealableDictionary <ITypeName, ICompiledType>(); InstancingRecordList = new List <TypeInstancingRecord>(); OriginatingTypedef = new OnceReference <ITypedef>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// True if the destination value has been set; /// </summary> /// <param name="node">The node for which the value is to be checked.</param> public override bool IsSet(TSource node) { OnceReference <TRef> Value = GetDestinationObject(node); Debug.Assert(Value == GetDestinationObject((ISource)node)); return(Value.IsAssigned); }
/// <summary> /// Propagates a list of exceptions if they are available. /// </summary> /// <param name="other">The optionally assigned list of exception.</param> /// <param name="result">The list of exceptions if available; Otherwise, null.</param> public static void Propagate(OnceReference <IResultException> other, out IResultException result) { if (other.IsAssigned) { result = other.Item; } else { result = null; } }
/// <summary> /// Checks if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { data = null; bool Result = false; OnceReference <TRef> Value = GetSourceObject(node, out bool IsInterrupted); if (!IsInterrupted && Value.IsAssigned) { data = Value.Item; Result = true; } return(Result); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { ValidText = new OnceReference <string>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ValidDiscreteName = new OnceReference <IFeatureName>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { IdentifierTable = new SealableDictionary <string, IIdentifier>(); ValidExportIdentifier = new OnceReference <string>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Checks if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { data = null; bool Result = false; OnceReference <IList <IIdentifier> > Value = GetSourceObject(node, out bool IsInterrupted); if (!IsInterrupted && Value.IsAssigned) { IList <IIdentifier> Path = Value.Item; foreach (IIdentifier Identifier in Path) { Debug.Assert(Identifier.ValidText.IsAssigned); } List <IEntityDeclaration> LocalEntityList = new List <IEntityDeclaration>(); if (node.EmbeddingOverload is ICommandOverload AsCommandOverload) { LocalEntityList.AddRange(AsCommandOverload.ParameterList); } else if (node.EmbeddingOverload is IQueryOverload AsQueryOverload) { LocalEntityList.AddRange(AsQueryOverload.ParameterList); LocalEntityList.AddRange(AsQueryOverload.ResultList); } if (node.EmbeddingBody is IEffectiveBody AsEffectiveBody) { LocalEntityList.AddRange(AsEffectiveBody.EntityDeclarationList); } IClass Class = node.EmbeddingClass; ISealableDictionary <IFeatureName, IFeatureInstance> LocalFeatureTable = Class.LocalFeatureTable; ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = Class.FeatureTable; IErrorList ErrorList = new ErrorList(); if (IsPathReady(Path, LocalEntityList, LocalFeatureTable, FeatureTable, ErrorList, out ITypeName ResolvedPathTypeName, out ICompiledType ResolvedPathType)) { data = new Tuple <IErrorList, ITypeName, ICompiledType>(ErrorList, ResolvedPathTypeName, ResolvedPathType); Result = true; } } return(Result); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedSourceTypeName = new OnceReference <ITypeName>(); ResolvedSourceType = new OnceReference <ICompiledType>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ValidExportName = new OnceReference <IFeatureName>(); ExportClassTable = new OnceReference <ISealableDictionary <string, IClass> >(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedAgentTypeName = new OnceReference <ITypeName>(); ResolvedAgentType = new OnceReference <ICompiledType>(); ResolvedEffectiveTypeName = new OnceReference <ITypeName>(); ResolvedEffectiveType = new OnceReference <ICompiledType>(); ValidFeatureName = new OnceReference <IFeatureName>(); ResolvedFeature = new OnceReference <ICompiledFeature>(); ResolvedEntityTypeName = new OnceReference <ITypeName>(); ResolvedEntityType = new OnceReference <ICompiledType>(); ParameterTable = new SealableList <IParameter>(); LocalScope = new SealableDictionary <string, IScopeAttributeFeature>(); LocalGetScope = new SealableDictionary <string, IScopeAttributeFeature>(); LocalSetScope = new SealableDictionary <string, IScopeAttributeFeature>(); InnerScopes = new List <IScopeHolder>(); InnerGetScopes = new List <IScopeHolder>(); InnerSetScopes = new List <IScopeHolder>(); FullScope = new SealableDictionary <string, IScopeAttributeFeature>(); FullGetScope = new SealableDictionary <string, IScopeAttributeFeature>(); FullSetScope = new SealableDictionary <string, IScopeAttributeFeature>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { AdditionalScope = new SealableDictionary <string, IScopeAttributeFeature>(); AdditionalScope.Seal(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { IsCallingPrecursor = false; IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedEntityTypeName = new OnceReference <ITypeName>(); ResolvedEntityType = new OnceReference <ICompiledType>(); ValidEntityName = new OnceReference <IFeatureName>(); ValidEntityInstance = new OnceReference <IFeatureInstance>(); ValidEntity = new OnceReference <IScopeAttributeFeature>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedGenericTypeName = new OnceReference <ITypeName>(); ResolvedGenericType = new OnceReference <IFormalGenericType>(); ResolvedDefaultType = new OnceReference <ICompiledType>(); ResolvedConformanceTable = new SealableDictionary <ITypeName, ICompiledType>(); TypeTable = new SealableDictionary <ITypeName, ICompiledType>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Contract) { ResolvedRange = new OnceReference <IConstantRange>(); IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Body) { ResolvedException = new OnceReference <IResultException>(); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Reset some intermediate results. /// </summary> /// <param name="ruleTemplateList">The list of rule templates that would read the properties to reset.</param> public void Reset(IRuleTemplateList ruleTemplateList) { bool IsHandled = false; if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body) { IsHandled = true; } else if (ruleTemplateList == RuleTemplateSet.Types) { ResolvedParentTypeName = new OnceReference <ITypeName>(); ResolvedParentType = new OnceReference <ICompiledType>(); ResolvedConformingTypeName = new OnceReference <ITypeName>(); ResolvedConformingType = new OnceReference <ICompiledType>(); RenameTable = new SealableDictionary <IIdentifier, IIdentifier>(); ResolvedTypeWithRename = new OnceReference <ICompiledType>(); IsHandled = true; } Debug.Assert(IsHandled); }