/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
IValueToAlias valueToAliasItem = item.As <IValueToAlias>();
if (((valueToAliasItem != null) &&
this._parent.Values.Remove(valueToAliasItem)))
{
return(true);
}
ICommand commandItem = item.As <ICommand>();
if (((commandItem != null) &&
this._parent.Commands.Remove(commandItem)))
{
return(true);
}
IDiscrete discreteItem = item.As <IDiscrete>();
if (((discreteItem != null) &&
this._parent.Discretes.Remove(discreteItem)))
{
return(true);
}
return(false);
}
private bool CheckNoCycle(IClass node, out IDictionary <Number, IDiscrete> combinedDiscreteNumericValueList)
{
bool Success = true;
combinedDiscreteNumericValueList = new Dictionary <Number, IDiscrete>();
foreach (KeyValuePair <IFeatureName, IExpression> Entry in node.DiscreteWithValueTable)
{
Debug.Assert(node.DiscreteTable.ContainsKey(Entry.Key));
IDiscrete DiscreteItem = node.DiscreteTable[Entry.Key];
IExpression NumericValue = (IExpression)DiscreteItem.NumericValue.Item;
ILanguageConstant ExpressionConstant = Expression.FinalConstant(NumericValue);
if (ExpressionConstant is INumberLanguageConstant AsNumberLanguageConstant && AsNumberLanguageConstant.IsValueKnown)
{
Number NumberConstant = AsNumberLanguageConstant.Value;
if (combinedDiscreteNumericValueList.ContainsKey(NumberConstant))
{
AddSourceError(new ErrorMultipleIdenticalDiscrete(DiscreteItem, NumberConstant));
Success = false;
}
else
{
combinedDiscreteNumericValueList.Add(AsNumberLanguageConstant.Value, DiscreteItem);
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IClass node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
Debug.Assert(node.LocalDiscreteTable.IsSealed);
ISealableDictionary <IFeatureName, IDiscrete> MergedDiscreteTable = node.LocalDiscreteTable.CloneUnsealed();
foreach (IInheritance Inheritance in node.InheritanceList)
{
Debug.Assert(Inheritance.ResolvedType.IsAssigned);
Debug.Assert(Inheritance.DiscreteTable.IsAssigned);
ISealableDictionary <IFeatureName, IDiscrete> InheritedDiscreteTable = Inheritance.DiscreteTable.Item;
foreach (KeyValuePair <IFeatureName, IDiscrete> InstanceEntry in InheritedDiscreteTable)
{
IFeatureName InstanceName = InstanceEntry.Key;
IDiscrete InstanceItem = InstanceEntry.Value;
bool ConflictingEntry = false;
foreach (KeyValuePair <IFeatureName, IDiscrete> Entry in MergedDiscreteTable)
{
IFeatureName LocalName = Entry.Key;
IDiscrete LocalItem = Entry.Value;
if (InstanceName.Name == LocalName.Name)
{
if (InstanceItem != LocalItem)
{
AddSourceError(new ErrorDuplicateName(Inheritance, LocalName.Name));
ConflictingEntry = true;
Success = false;
}
}
else if (InstanceItem == LocalItem)
{
AddSourceError(new ErrorDiscreteNameConflict(Inheritance, LocalName.Name, InstanceName.Name));
ConflictingEntry = true;
Success = false;
}
}
if (!ConflictingEntry && !MergedDiscreteTable.ContainsKey(InstanceName))
{
MergedDiscreteTable.Add(InstanceName, InstanceItem);
}
}
}
if (Success)
{
data = MergedDiscreteTable;
}
return(Success);
}
/// <summary>
/// Checks if another constant can be compared with this instance.
/// </summary>
/// <param name="other">The other instance.</param>
public override bool IsCompatibleWith(ILanguageConstant other)
{
bool Result = false;
if (other is IDiscreteLanguageConstant AsDiscreteLanguageConstant && IsValueKnown && AsDiscreteLanguageConstant.IsValueKnown)
{
IDiscrete OtherDiscrete = AsDiscreteLanguageConstant.Discrete;
Result = Discrete.EmbeddingClass == OtherDiscrete.EmbeddingClass;
}
return(Result);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Discrete == null))
{
IDiscrete discreteCasted = item.As <IDiscrete>();
if ((discreteCasted != null))
{
this._parent.Discrete = discreteCasted;
return;
}
}
}
/// <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(IEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item5;
IDiscrete ResolvedFinalDiscrete = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item6;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <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(IClassConstantExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item4;
Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> AdditionalData = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item5;
IConstantFeature ResolvedFinalFeature = AdditionalData.Item1;
IDiscrete ResolvedFinalDiscrete = AdditionalData.Item2;
ITypeName ResolvedClassTypeName = AdditionalData.Item3;
IClassType ResolvedClassType = AdditionalData.Item4;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Checks if another constant is equal to this instance.
/// </summary>
/// <param name="other">The other instance.</param>
protected virtual bool IsConstantEqual(IDiscreteLanguageConstant other)
{
Debug.Assert(other != null && Discrete != null && other.Discrete != null);
IDiscrete OtherDiscrete = other.Discrete;
IClass EmbeddingClass = Discrete.EmbeddingClass;
Debug.Assert(EmbeddingClass != null);
Debug.Assert(EmbeddingClass == OtherDiscrete.EmbeddingClass);
int ThisDiscreteIndex = EmbeddingClass.DiscreteList.IndexOf(Discrete);
int OtherDiscreteIndex = EmbeddingClass.DiscreteList.IndexOf(OtherDiscrete);
Debug.Assert(ThisDiscreteIndex != -1 && OtherDiscreteIndex != -1);
return(ThisDiscreteIndex == OtherDiscreteIndex);
}
/// <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(IClassConstantExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item4;
Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> AdditionalData = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, Tuple <IConstantFeature, IDiscrete, ITypeName, IClassType> >)data).Item5;
IConstantFeature ResolvedFinalFeature = AdditionalData.Item1;
IDiscrete ResolvedFinalDiscrete = AdditionalData.Item2;
ITypeName ResolvedClassTypeName = AdditionalData.Item3;
IClassType ResolvedClassType = AdditionalData.Item4;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
if (ConstantSourceList.Count == 0)
{
IDiscreteLanguageConstant DiscreteLanguageConstant = ExpressionConstant as IDiscreteLanguageConstant;
Debug.Assert(DiscreteLanguageConstant != null);
Debug.Assert(DiscreteLanguageConstant.IsValueKnown);
node.ExpressionConstant.Item = ExpressionConstant;
}
else
{
Debug.Assert(ConstantSourceList.Count == 1);
}
node.ResolvedClassTypeName.Item = ResolvedClassTypeName;
node.ResolvedClassType.Item = ResolvedClassType;
Debug.Assert(ResolvedFinalFeature != null || ResolvedFinalDiscrete != null);
if (ResolvedFinalFeature != null)
{
node.ResolvedFinalFeature.Item = ResolvedFinalFeature;
}
if (ResolvedFinalDiscrete != null)
{
node.ResolvedFinalDiscrete.Item = ResolvedFinalDiscrete;
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IValueToAlias valuesCasted = item.As <IValueToAlias>();
if ((valuesCasted != null))
{
this._parent.Values.Add(valuesCasted);
}
ICommand commandsCasted = item.As <ICommand>();
if ((commandsCasted != null))
{
this._parent.Commands.Add(commandsCasted);
}
IDiscrete discretesCasted = item.As <IDiscrete>();
if ((discretesCasted != null))
{
this._parent.Discretes.Add(discretesCasted);
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.ValueAliasSet == null))
{
IValueAliasSet valueAliasSetCasted = item.As <IValueAliasSet>();
if ((valueAliasSetCasted != null))
{
this._parent.ValueAliasSet = valueAliasSetCasted;
return;
}
}
if ((this._parent.Discrete == null))
{
IDiscrete discreteCasted = item.As <IDiscrete>();
if ((discreteCasted != null))
{
this._parent.Discrete = discreteCasted;
return;
}
}
}
/// <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(IEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item5;
IDiscrete ResolvedFinalDiscrete = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item6;
node.ResolvedException.Item = ResolvedException;
if (ResolvedFinalFeature != null)
{
node.ResolvedFinalFeature.Item = ResolvedFinalFeature;
}
if (ResolvedFinalDiscrete != null)
{
node.ResolvedFinalDiscrete.Item = ResolvedFinalDiscrete;
}
}
private void AddValueToList(IConstantRange range)
{
if (LanguageConstant.TryParseInt(range.Minimum, out int IntMinimum) && LanguageConstant.TryParseInt(range.Maximum, out int IntMaximum))
{
ConstantList.Add(range.Minimum);
if (IntMinimum < IntMaximum)
{
for (int i = IntMinimum + 1; i < IntMaximum; i++)
{
ConstantList.Add(new NumberLanguageConstant(new Number(i)));
}
ConstantList.Add(range.Maximum);
}
}
else if (range.Minimum is DiscreteLanguageConstant AsDiscreteMinimum && AsDiscreteMinimum.IsValueKnown && range.Maximum is DiscreteLanguageConstant AsDiscreteMaximum && AsDiscreteMaximum.IsValueKnown)
{
ConstantList.Add(AsDiscreteMinimum);
if (AsDiscreteMaximum.IsConstantGreater(AsDiscreteMinimum))
{
IClass EmbeddingClass = AsDiscreteMinimum.Discrete.EmbeddingClass;
int DiscreteMinimumIndex = EmbeddingClass.DiscreteList.IndexOf(AsDiscreteMinimum.Discrete);
int DiscreteMaximumIndex = EmbeddingClass.DiscreteList.IndexOf(AsDiscreteMaximum.Discrete);
if (DiscreteMinimumIndex >= 0 && DiscreteMaximumIndex >= 0)
{
for (int Index = DiscreteMinimumIndex + 1; Index < DiscreteMaximumIndex; Index++)
{
IDiscrete MiddleDiscrete = EmbeddingClass.DiscreteList[Index];
DiscreteLanguageConstant MiddleConstant = new DiscreteLanguageConstant(MiddleDiscrete);
ConstantList.Add(MiddleConstant);
}
}
}
}
}
/// <summary>
/// Writes down the C# conditional instructions.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public virtual void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
foreach (ILanguageConstant Constant in ConstantList)
{
bool IsHandled = false;
switch (Constant)
{
case INumberLanguageConstant AsManifestConstant:
Number AsNumber = AsManifestConstant.Value;
if (AsNumber.TryParseInt(out int IntValue))
{
writer.WriteIndentedLine($"case {IntValue}:");
IsHandled = true;
}
break;
case IDiscreteLanguageConstant AsDiscreteConstant:
IDiscrete DiscreteItem = AsDiscreteConstant.Discrete;
IName ClassEntityName = (IName)DiscreteItem.EmbeddingClass.EntityName;
string ClassName = CSharpNames.ToCSharpIdentifier(ClassEntityName.ValidText.Item);
IFeatureName DiscreteFeatureName = DiscreteItem.ValidDiscreteName.Item;
string DiscreteName = CSharpNames.ToCSharpIdentifier(DiscreteFeatureName.Name);
writer.WriteIndentedLine($"case {ClassName}.{DiscreteName}:");
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
Instructions.WriteCSharp(writer, CSharpCurlyBracketsInsertions.Indifferent, true);
}
/// <summary>
/// Gets the object a path is refering to.
/// </summary>
/// <param name="baseClass">The class where the path is used.</param>
/// <param name="baseType">The type at the start of the path.</param>
/// <param name="localScope">The local scope.</param>
/// <param name="validPath">The path.</param>
/// <param name="index">Index of the current identifier in the path.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="finalFeature">The feature at the end of the path, if any, upon return.</param>
/// <param name="finalDiscrete">The discrete at the end of the path, if any, upon return.</param>
/// <param name="finalTypeName">The type name of the result.</param>
/// <param name="finalType">The type of the result.</param>
/// <param name="inheritBySideAttribute">Inherited from an effective body.</param>
public static bool GetQualifiedPathFinalType(IClass baseClass, ICompiledType baseType, ISealableDictionary <string, IScopeAttributeFeature> localScope, IList <IIdentifier> validPath, int index, IErrorList errorList, out ICompiledFeature finalFeature, out IDiscrete finalDiscrete, out ITypeName finalTypeName, out ICompiledType finalType, out bool inheritBySideAttribute)
{
finalFeature = null;
finalDiscrete = null;
finalTypeName = null;
finalType = null;
inheritBySideAttribute = false;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = baseType.FeatureTable;
IIdentifier ValidIdentifier = validPath[index];
string ValidText = ValidIdentifier.ValidText.Item;
if (index == 0 && localScope.ContainsKey(ValidText))
{
return(GetQualifiedPathFinalTypeFromLocal(baseClass, baseType, localScope, validPath, index, errorList, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
else if (FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance))
{
return(GetQualifiedPathFinalTypeAsFeature(baseClass, baseType, localScope, validPath, index, errorList, Instance, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityLanguageConstant"/> class.
/// </summary>
/// <param name="value">The constant value.</param>
public EntityLanguageConstant(IDiscrete value)
{
Value = value;
}
private static bool ResolveDiscrete(IQueryExpression node, IErrorList errorList, IDiscrete resolvedFinalDiscrete, ref ResolvedExpression resolvedExpression)
{
// This is enforced by the caller.
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
Debug.Assert(IsNumberTypeAvailable);
resolvedExpression.ResolvedResult = new ResultType(NumberTypeName, NumberType, resolvedFinalDiscrete.ValidDiscreteName.Item.Name);
resolvedExpression.ResolvedException = new ResultException();
if (resolvedFinalDiscrete.NumericValue.IsAssigned)
{
IExpression NumericValue = (IExpression)resolvedFinalDiscrete.NumericValue.Item;
resolvedExpression.ConstantSourceList.Add(NumericValue);
}
else
{
resolvedExpression.ExpressionConstant = new DiscreteLanguageConstant(resolvedFinalDiscrete);
}
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
return(true);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IClassConstantExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The expression constant upon return.</param>
/// <param name="resolvedFinalFeature">The feature if the end of the path is a feature.</param>
/// <param name="resolvedFinalDiscrete">The discrete if the end of the path is a discrete.</param>
/// <param name="resolvedClassTypeName">The class type name upon return.</param>
/// <param name="resolvedClassType">The class name upon return.</param>
public static bool ResolveCompilerReferences(IClassConstantExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out IConstantFeature resolvedFinalFeature, out IDiscrete resolvedFinalDiscrete, out ITypeName resolvedClassTypeName, out IClassType resolvedClassType)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
resolvedFinalFeature = null;
resolvedFinalDiscrete = null;
resolvedClassTypeName = null;
resolvedClassType = null;
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
IIdentifier ConstantIdentifier = (IIdentifier)node.ConstantIdentifier;
IClass EmbeddingClass = node.EmbeddingClass;
string ValidClassText = ClassIdentifier.ValidText.Item;
string ValidConstantText = ConstantIdentifier.ValidText.Item;
ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable;
if (!ClassTable.ContainsKey(ValidClassText))
{
errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidClassText));
return(false);
}
IClass BaseClass = ClassTable[ValidClassText].Item;
resolvedClassTypeName = BaseClass.ResolvedClassTypeName.Item;
resolvedClassType = BaseClass.ResolvedClassType.Item;
ITypeName ConstantTypeName;
ICompiledType ConstantType;
ISealableDictionary <IFeatureName, IDiscrete> DiscreteTable = BaseClass.DiscreteTable;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = BaseClass.FeatureTable;
if (FeatureName.TableContain(DiscreteTable, ValidConstantText, out IFeatureName Key, out IDiscrete Discrete))
{
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType))
{
errorList.AddError(new ErrorNumberTypeMissing(node));
return(false);
}
if (Discrete.NumericValue.IsAssigned)
{
constantSourceList.Add((IExpression)Discrete.NumericValue.Item);
}
else
{
expressionConstant = new DiscreteLanguageConstant(Discrete);
}
resolvedFinalDiscrete = Discrete;
ConstantTypeName = NumberTypeName;
ConstantType = NumberType;
}
/// <summary>
/// Finds the matching nodes of a <see cref="IEntityExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The expression constant upon return.</param>
/// <param name="resolvedFinalFeature">The feature if the end of the path is a feature.</param>
/// <param name="resolvedFinalDiscrete">The discrete if the end of the path is a discrete.</param>
public static bool ResolveCompilerReferences(IEntityExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out ICompiledFeature resolvedFinalFeature, out IDiscrete resolvedFinalDiscrete)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
resolvedFinalFeature = null;
resolvedFinalDiscrete = null;
IQualifiedName Query = (IQualifiedName)node.Query;
IClass EmbeddingClass = (Class)node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Entity.Guid, node, out ITypeName ResultTypeName, out ICompiledType ResultType))
{
errorList.AddError(new ErrorEntityTypeMissing(node));
return(false);
}
IList <IIdentifier> ValidPath = Query.ValidPath.Item;
IIdentifier LastIdentifier = ValidPath[ValidPath.Count - 1];
string ValidText = LastIdentifier.ValidText.Item;
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, errorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute))
{
return(false);
}
Guid EntityGuid;
if (FinalFeature is IFeatureWithEntity AsFeatureWithEntity)
{
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item);
resolvedFinalFeature = FinalFeature;
EntityGuid = AsFeatureWithEntity.EntityGuid;
expressionConstant = new EntityLanguageConstant(AsFeatureWithEntity);
}
else
{
Debug.Assert(FinalDiscrete != null);
resolvedFinalDiscrete = FinalDiscrete;
EntityGuid = LanguageClasses.NamedFeatureEntity.Guid;
expressionConstant = new EntityLanguageConstant(resolvedFinalDiscrete);
}
ITypeName EntityTypeName = EmbeddingClass.ImportedLanguageTypeTable[EntityGuid].Item1;
ICompiledType EntityType = EmbeddingClass.ImportedLanguageTypeTable[EntityGuid].Item2;
resolvedResult = new ResultType(EntityTypeName, EntityType, ValidText);
resolvedException = new ResultException();
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscreteLanguageConstant"/> class.
/// </summary>
/// <param name="discrete">The discrete constant.</param>
public DiscreteLanguageConstant(IDiscrete discrete)
{
Discrete = discrete;
}
