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);
}
