/// <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>
/// 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 || 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>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers)
{
IsResolved = ValidPath.IsAssigned;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types || ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ValidResultTypePath.IsAssigned;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types)
{
Debug.Assert(ResolvedTypeName.IsAssigned == ResolvedType.IsAssigned);
IsResolved = ResolvedType.IsAssigned;
Debug.Assert(ExportTable.IsAssigned == IsResolved);
Debug.Assert(TypedefTable.IsAssigned == IsResolved);
Debug.Assert(DiscreteTable.IsAssigned == IsResolved);
Debug.Assert(FeatureTable.IsAssigned == IsResolved);
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ResolvedBodyTagList.IsAssigned;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = AssignedDiscreteTable.IsSealed;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types)
{
Debug.Assert(ResolvedEntityTypeName.IsAssigned == ResolvedEntityType.IsAssigned);
Debug.Assert(ResolvedAgentTypeName.IsAssigned == ResolvedAgentType.IsAssigned);
Debug.Assert(ResolvedEffectiveTypeName.IsAssigned == ResolvedEffectiveType.IsAssigned);
IsResolved = ResolvedFeature.IsAssigned;
Debug.Assert(ResolvedEntityType.IsAssigned || !IsResolved);
Debug.Assert(ResolvedAgentType.IsAssigned || !IsResolved);
Debug.Assert(ResolvedEffectiveType.IsAssigned || !IsResolved);
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <summary>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types)
{
IsResolved = NamespaceTable.IsSealed;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ResolvedBodyTagList.IsAssigned && ResolvedNodeWithDefaultList.IsAssigned && ResolvedNodeWithNumberConstantList.IsAssigned && InheritedBodyTagListTable.IsSealed;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = ResolvedBodyList.IsAssigned && AssignedDiscreteTable.IsSealed;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <summary>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types)
{
IsResolved = LocalScope.IsSealed;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ResolvedResult.IsAssigned;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = ResolvedType.IsAssigned;
Debug.Assert(ResolvedException.IsAssigned || !IsResolved);
Debug.Assert(FeatureCall.IsAssigned || !IsResolved);
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ResolvedResult.IsAssigned && ResolvedRequireList.IsAssigned && ResolvedEnsureList.IsAssigned && ResolvedExceptionIdentifierList.IsAssigned;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = ResolvedInstructionList.IsAssigned;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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);
}
/// <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)
{
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>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ExpressionConstant.IsAssigned;
Debug.Assert(ResolvedResult.IsAssigned || !IsResolved);
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = ResolvedException.IsAssigned;
Debug.Assert(ResolvedFinalFeature.IsAssigned || !IsResolved);
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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 rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = false;
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Types)
{
IsResolved = LocalScope.IsSealed;
Debug.Assert(ParameterTable.IsSealed == IsResolved);
IsHandled = true;
}
else if (ruleTemplateList == RuleTemplateSet.Contract)
{
IsResolved = ResolvedBody.IsAssigned;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <summary>
/// Initializes a new instance of the <see cref="InferenceEngine"/> class.
/// </summary>
/// <param name="ruleTemplateList">The set of rules to execute.</param>
/// <param name="sourceList">The list of nodes on which rules are checked and applied.</param>
/// <param name="classList">The list of classes to resolve.</param>
/// <param name="isCycleErrorChecked">True if the engine should check for cyclic dependencies errors.</param>
/// <param name="retries">Number of retries (debug only).</param>
public InferenceEngine(IRuleTemplateList ruleTemplateList, IList <ISource> sourceList, IList <IClass> classList, bool isCycleErrorChecked, int retries)
{
RuleTemplateList = ruleTemplateList;
SourceList = sourceList;
ClassList = classList;
IsCycleErrorChecked = isCycleErrorChecked;
Retries = retries;
}
/// <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 || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body)
{
IsHandled = true;
}
Debug.Assert(IsHandled);
}
/// <summary>
/// Checks if a rule is resolved for this source.
/// </summary>
/// <param name="ruleTemplateList">The list of rule templates that would read the properties to check.</param>
public virtual bool IsResolved(IRuleTemplateList ruleTemplateList)
{
bool IsResolved = false;
bool IsHandled = false;
if (ruleTemplateList == RuleTemplateSet.Identifiers || ruleTemplateList == RuleTemplateSet.Types || ruleTemplateList == RuleTemplateSet.Contract || ruleTemplateList == RuleTemplateSet.Body)
{
IsResolved = false;
IsHandled = true;
}
Debug.Assert(IsHandled);
return(IsResolved);
}
/// <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)
{
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)
{
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)
{
TypeName = null;
ParameterTable = new SealableList <IParameter>();
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)
{
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>
/// 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)
{
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);
}
