/// <summary>
/// Finds the matching nodes of a <see cref="IResultOfExpression"/>.
/// </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>
public static bool ResolveCompilerReferences(IResultOfExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
IExpression Source = (IExpression)node.Source;
IResultType ResolvedSourceResult = Source.ResolvedResult.Item;
int ResultNameIndex = ResolvedSourceResult.ResultNameIndex;
if (ResultNameIndex < 0)
{
errorList.AddError(new ErrorInvalidExpression(node));
return(false);
}
Debug.Assert(ResolvedSourceResult.Preferred != null);
resolvedResult = new ResultType(ResolvedSourceResult.Preferred);
constantSourceList.Add(Source);
ResultException.Propagate(Source.ResolvedException, out resolvedException);
#if COVERAGE
Debug.Assert(node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpUnaryOperatorExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpUnaryOperatorExpression(ICSharpContext context, IUnaryOperatorExpression source)
: base(context, source)
{
RightExpression = Create(context, (IExpression)source.RightExpression);
Operator = context.GetFeature(source.SelectedFeature.Item) as ICSharpFunctionFeature;
Debug.Assert(Operator != null);
FeatureCall = new CSharpFeatureCall(context, new FeatureCall());
IResultType ResolvedRightResult = RightExpression.Source.ResolvedResult.Item;
IExpressionType PreferredRightResult = ResolvedRightResult.Preferred;
Debug.Assert(PreferredRightResult != null);
if (PreferredRightResult.ValueType is IClassType AsClassType)
{
if (AsClassType.BaseClass.ClassGuid == LanguageClasses.Number.Guid)
{
IsCallingNumberFeature = true;
}
}
if (IsCallingNumberFeature)
{
Debug.Assert(ResolvedRightResult.Count == 1);
}
Debug.Assert(Source.SelectedOverload.IsAssigned);
IQueryOverload Overload = Source.SelectedOverload.Item;
IQueryOverloadType ResolvedAssociatedType = Overload.ResolvedAssociatedType.Item;
SelectedOverloadType = CSharpQueryOverloadType.Create(context, ResolvedAssociatedType, Operator.Owner);
}
/// <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(IInitializedObjectExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item4;
ITypeName InitializedObjectTypeName = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item5;
IClassType InitializedObjectType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item6;
ISealableDictionary <string, ICompiledFeature> AssignedFeatureTable = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item7;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.ResolvedClassTypeName.Item = InitializedObjectTypeName;
node.ResolvedClassType.Item = InitializedObjectType;
Debug.Assert(node.AssignedFeatureTable.Count == 0);
node.AssignedFeatureTable.Merge(AssignedFeatureTable);
node.AssignedFeatureTable.Seal();
IClass BaseClass = InitializedObjectType.BaseClass;
BaseClass.InitializedObjectList.Add(node);
}
/// <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(IAssignmentInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
// This list has been verified during the node tree check.
Debug.Assert(node.DestinationList.Count > 0);
IExpression SourceExpression = (IExpression)node.Source;
IResultType SourceResult = SourceExpression.ResolvedResult.Item;
if (node.DestinationList.Count > SourceResult.Count)
{
AddSourceError(new ErrorAssignmentMismatch(node));
Success = false;
}
else
{
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
ISealableDictionary <IQualifiedName, ICompiledFeature> FinalFeatureTable = new SealableDictionary <IQualifiedName, ICompiledFeature>();
for (int i = 0; i < node.DestinationList.Count; i++)
{
IQualifiedName Destination = (QualifiedName)node.DestinationList[i];
IList <IIdentifier> ValidPath = Destination.ValidPath.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))
{
Success = false;
}
/// <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(IFunctionFeature node, object data)
{
IClass EmbeddingClass = node.EmbeddingClass;
ITypeName BaseTypeName = EmbeddingClass.ResolvedClassTypeName.Item;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
IResultType CommonResults = (IResultType)data;
IList <IQueryOverloadType> OverloadList = new List <IQueryOverloadType>();
foreach (IQueryOverload Overload in node.OverloadList)
{
Debug.Assert(Overload.ResolvedAssociatedType.IsAssigned);
OverloadList.Add(Overload.ResolvedAssociatedType.Item);
}
ITypeName ResolvedFunctionTypeName;
IFunctionType ResolvedFunctionType;
FunctionType.ResolveType(EmbeddingClass.TypeTable, BaseTypeName, BaseType.SourceType, BaseType, OverloadList, out ResolvedFunctionTypeName, out ResolvedFunctionType);
node.ResolvedAgentTypeName.Item = ResolvedFunctionTypeName;
node.ResolvedAgentType.Item = ResolvedFunctionType;
node.ResolvedFeature.Item = node;
#if COVERAGE
string TypeString = ResolvedFunctionType.ToString();
#endif
}
/// <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(IAttachmentInstruction node, object data)
{
IExpression AttachmentSource = (IExpression)node.Source;
IResultType SourceTypeList = AttachmentSource.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
IList <IList <ITypeName> > FullAttachmentTypeNameList = ((Tuple <IList <IList <ITypeName> >, IList <IList <ICompiledType> > >)data).Item1;
IList <IList <ICompiledType> > FullAttachmentTypeList = ((Tuple <IList <IList <ITypeName> >, IList <IList <ICompiledType> > >)data).Item2;
for (int i = 0; i < node.EntityNameList.Count; i++)
{
IExpressionType Item = SourceTypeList.At(i);
IName ItemName = node.EntityNameList[i];
string ValidText = ItemName.ValidText.Item;
IList <ITypeName> AttachmentTypeNameList = FullAttachmentTypeNameList[i];
IList <ICompiledType> AttachmentTypeList = FullAttachmentTypeList[i];
for (int j = 0; j < node.AttachmentList.Count; j++)
{
IAttachment Attachment = node.AttachmentList[j];
ITypeName AttachmentTypeName = AttachmentTypeNameList[j];
ICompiledType AttachmentType = AttachmentTypeList[j];
IScopeAttributeFeature TypeFixedEntity = Attachment.FullScope[ValidText];
TypeFixedEntity.FixFeatureType(AttachmentTypeName, AttachmentType);
Attachment.ResolvedLocalEntitiesList.Add(TypeFixedEntity);
}
}
node.ResolvedInitResult.Item = ResultType.Empty;
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpAttachmentInstruction"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="parentFeature">The parent feature.</param>
/// <param name="source">The Easly instruction from which the C# instruction is created.</param>
protected CSharpAttachmentInstruction(ICSharpContext context, ICSharpFeature parentFeature, IAttachmentInstruction source)
: base(context, parentFeature, source)
{
SourceExpression = CSharpExpression.Create(context, (IExpression)source.Source);
IResultType ResolvedResult = SourceExpression.Source.ResolvedResult.Item;
for (int i = 0; i < source.EntityNameList.Count; i++)
{
IName EntityName = source.EntityNameList[i];
string ValidName = EntityName.ValidText.Item;
EntityNameList.Add(new CSharpVariableContext(ValidName));
}
foreach (IAttachment Attachment in source.AttachmentList)
{
ICSharpAttachment NewAttachment = CSharpAttachment.Create(context, this, Attachment);
AttachmentList.Add(NewAttachment);
}
if (source.ElseInstructions.IsAssigned)
{
ElseInstructions = CSharpScope.Create(context, parentFeature, (IScope)source.ElseInstructions.Item);
}
}
/// <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(IAttachmentInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression AttachmentSource = (IExpression)node.Source;
IResultType SourceTypeList = AttachmentSource.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
IList <IList <ITypeName> > FullAttachmentTypeNameList = new List <IList <ITypeName> >();
IList <IList <ICompiledType> > FullAttachmentTypeList = new List <IList <ICompiledType> >();
if (SourceTypeList.Count < node.EntityNameList.Count)
{
AddSourceError(new ErrorInvalidInstruction(node));
Success = false;
}
else
{
for (int i = 0; i < node.EntityNameList.Count; i++)
{
IList <ITypeName> AttachmentTypeNameList = new List <ITypeName>();
IList <ICompiledType> AttachmentTypeList = new List <ICompiledType>();
FullAttachmentTypeNameList.Add(AttachmentTypeNameList);
FullAttachmentTypeList.Add(AttachmentTypeList);
}
for (int i = 0; i < node.EntityNameList.Count; i++)
{
IExpressionType Item = SourceTypeList.At(i);
IName ItemName = node.EntityNameList[i];
IList <ITypeName> AttachmentTypeNameList = FullAttachmentTypeNameList[i];
IList <ICompiledType> AttachmentTypeList = FullAttachmentTypeList[i];
foreach (IAttachment Attachment in node.AttachmentList)
{
IObjectType AttachedType = Attachment.AttachTypeList[i];
ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = Attachment.FullScope;
IList <IClass> AssignedSingleClassList = new List <IClass>();
IErrorList CheckErrorList = new ErrorList();
if (ScopeHolder.HasConflictingSingleAttributes(CheckedScope, node.InnerScopes, AssignedSingleClassList, node, CheckErrorList))
{
AddSourceErrorList(CheckErrorList);
Success = false;
}
AttachmentTypeNameList.Add(AttachedType.ResolvedTypeName.Item);
AttachmentTypeList.Add(AttachedType.ResolvedType.Item);
}
}
data = new Tuple <IList <IList <ITypeName> >, IList <IList <ICompiledType> > >(FullAttachmentTypeNameList, FullAttachmentTypeList);
}
return(Success);
}
/// <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(IOverLoopInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression OverList = (IExpression)node.OverList;
IResultType OverTypeList = OverList.ResolvedResult.Item;
IScope LoopInstructions = (IScope)node.LoopInstructions;
IClass EmbeddingClass = node.EmbeddingClass;
bool IsOverLoopSourceTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.OverLoopSource.Guid, node, out ITypeName OverLoopSourceTypeName, out ICompiledType OverLoopSourceType);
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
foreach (IExpressionType Item in OverTypeList)
{
ICompiledType ResultType = Item.ValueType;
IErrorList OverSourceErrorList = new ErrorList();
bool IsConformantToEnumerable = false;
bool IsConformantToNumericIndexer = false;
if (IsOverLoopSourceTypeAvailable && ObjectType.TypeConformToBase(ResultType, OverLoopSourceType, isConversionAllowed: true))
{
IsConformantToEnumerable = true;
}
if (IsNumberTypeAvailable && ResultType.FeatureTable.ContainsKey(FeatureName.IndexerFeatureName))
{
IFeatureInstance IndexerInstance = ResultType.FeatureTable[FeatureName.IndexerFeatureName];
IIndexerFeature IndexerFeature = IndexerInstance.Feature as IIndexerFeature;
Debug.Assert(IndexerFeature != null);
if (IndexerFeature.IndexParameterList.Count == 1)
{
IEntityDeclaration IndexParameterDeclaration = IndexerFeature.IndexParameterList[0];
if (IndexParameterDeclaration.ValidEntity.Item.ResolvedEffectiveType.Item == NumberType)
{
IsConformantToNumericIndexer = true;
}
}
}
Debug.Assert(IsConformantToEnumerable != IsConformantToNumericIndexer);
}
IResultException ResolvedException = new ResultException();
ResultException.Merge(ResolvedException, OverList.ResolvedException.Item);
ResultException.Merge(ResolvedException, LoopInstructions.ResolvedException.Item);
foreach (IAssertion Item in node.InvariantList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
data = ResolvedException;
return(Success);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IFunctionType node, object data)
{
IResultType CommonResults = (IResultType)data;
int Index = CommonResults.ResultNameIndex >= 0 ? CommonResults.ResultNameIndex : 0;
IExpressionType MostCommonResult = CommonResults.At(Index);
node.MostCommonResult.Item = MostCommonResult;
}
/// <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(IKeywordEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item4;
node.ResolvedException.Item = ResolvedException;
}
/// <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(IAgentExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
node.ResolvedException.Item = ResolvedException;
}
/// <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(IPrecursorIndexAssignmentInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression SourceExpression = (IExpression)node.Source;
IResultType SourceResult = SourceExpression.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = EmbeddingClass.FeatureTable;
IFeature InnerFeature = node.EmbeddingFeature;
if (InnerFeature is IIndexerFeature AsIndexerFeature)
{
IFeatureInstance Instance = FeatureTable[AsIndexerFeature.ValidFeatureName.Item];
if (!Instance.FindPrecursor(node.AncestorType, ErrorList, node, out IFeatureInstance SelectedPrecursor))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >();
ICompiledFeature OperatorFeature = SelectedPrecursor.Feature;
IIndexerType AsIndexerType = OperatorFeature.ResolvedAgentType.Item as IIndexerType;
Debug.Assert(AsIndexerType != null);
ParameterTableList.Add(AsIndexerType.ParameterTable);
ResultTableList.Add(new SealableList <IParameter>());
if (!Argument.CheckAssignmentConformance(ParameterTableList, ResultTableList, node.ArgumentList, SourceExpression, AsIndexerType.ResolvedEntityType.Item, ErrorList, node, out IFeatureCall FeatureCall))
{
return(false);
}
IResultException ResolvedException = new ResultException();
ResultException.Merge(ResolvedException, SourceExpression.ResolvedException.Item);
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, AsIndexerType.SetExceptionIdentifierList);
data = new Tuple <IResultException, IFeatureCall>(ResolvedException, FeatureCall);
}
else
{
AddSourceError(new ErrorInvalidInstruction(node));
return(false);
}
return(Success);
}
/// <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(IForLoopInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression WhileCondition = (IExpression)node.WhileCondition;
IResultType ResolvedResult = WhileCondition.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (ResolvedResult.Count > 1)
{
AddSourceError(new ErrorInvalidExpression(WhileCondition));
Success = false;
}
else if (!IsForLoopTypeAvailable(node))
{
Success = false;
}
else
{
IResultException ResolvedException = new ResultException();
foreach (IInstruction Item in node.InitInstructionList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, WhileCondition.ResolvedException.Item);
foreach (IInstruction Item in node.LoopInstructionList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
foreach (IInstruction Item in node.IterationInstructionList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
foreach (Assertion Item in node.InvariantList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
if (node.Variant.IsAssigned)
{
IExpression Variant = (IExpression)node.Variant.Item;
ResultException.Merge(ResolvedException, Variant.ResolvedException.Item);
}
data = ResolvedException;
}
return(Success);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IAssertionTagExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant>)data).Item4;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
}
/// <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(IInspectInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
IExpression Source = (IExpression)node.Source;
IResultType ResolvedResult = Source.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (ResolvedResult.Count > 1)
{
AddSourceError(new ErrorInvalidExpression(Source));
return(false);
}
ICompiledType ValueType = ResolvedResult.At(0).ValueType;
ISealableDictionary <IFeatureName, IDiscrete> EnforcedDiscreteTable = null;
if (ValueType is IClassType AsClassType)
{
if (!CheckConsistencyClassType(node, AsClassType, ref EnforcedDiscreteTable))
{
return(false);
}
}
else
{
AddSourceError(new ErrorInvalidExpression(Source));
return(false);
}
if (!CheckConsistencyRange(node, EnforcedDiscreteTable))
{
return(false);
}
IResultException ResolvedException = new ResultException();
ResultException.Merge(ResolvedException, Source.ResolvedException.Item);
foreach (IWith Item in node.WithList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
if (node.ElseInstructions.IsAssigned)
{
IScope ElseInstructions = (IScope)node.ElseInstructions.Item;
ResultException.Merge(ResolvedException, ElseInstructions.ResolvedException.Item);
}
data = ResolvedException;
return(true);
}
/// <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(IFunctionFeature node, object data)
{
IResultType CommonResults = (IResultType)data;
int Index = CommonResults.ResultNameIndex >= 0 ? CommonResults.ResultNameIndex : 0;
IExpressionType MostCommonResult = CommonResults.At(Index);
node.MostCommonResult.Item = MostCommonResult;
node.ResolvedEffectiveTypeName.Item = MostCommonResult.ValueTypeName;
node.ResolvedEffectiveType.Item = MostCommonResult.ValueType;
}
/// <summary>
/// Adds to a list of constant sources from a list of arguments.
/// </summary>
/// <param name="expression">The source expression.</param>
/// <param name="resultType">The expression result type.</param>
/// <param name="argumentList">The list of arguments.</param>
/// <param name="constantSourceList">The list of constant sources.</param>
/// <param name="expressionConstant">The constant if there are no arguments upon return.</param>
public static void AddConstantArguments(IExpression expression, IResultType resultType, IList <IArgument> argumentList, ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
{
if (argumentList.Count == 0)
{
expressionConstant = Expression.GetDefaultConstant(expression, resultType);
}
else
{
expressionConstant = NeutralLanguageConstant.NotConstant;
AddConstantArguments(argumentList, constantSourceList);
}
}
/// <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(IInitializedObjectExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item4;
ITypeName InitializedObjectTypeName = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item5;
IClassType InitializedObjectType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item6;
ISealableDictionary <string, ICompiledFeature> AssignedFeatureTable = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ITypeName, IClassType, ISealableDictionary <string, ICompiledFeature> >)data).Item7;
node.ResolvedException.Item = ResolvedException;
}
/// <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(IUnaryOperatorExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item4;
IFunctionFeature SelectedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item5;
IQueryOverload SelectedOverload = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item6;
IQueryOverloadType SelectedOverloadType = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IQueryOverloadType>)data).Item7;
node.ResolvedException.Item = ResolvedException;
}
/// <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(INewExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
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 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(IAsLongAsInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression ContinueCondition = (IExpression)node.ContinueCondition;
IResultType ResolvedResult = ContinueCondition.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType))
{
AddSourceError(new ErrorBooleanTypeMissing(node));
Success = false;
}
/// <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(IConditional node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression BooleanExpression = (IExpression)node.BooleanExpression;
IScope Instructions = (IScope)node.Instructions;
IResultType ResolvedResult = BooleanExpression.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (ResolvedResult.Count > 1)
{
AddSourceError(new ErrorInvalidExpression(BooleanExpression));
Success = false;
}
else
{
bool IsBooleanTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType);
bool IsEventTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Event.Guid, node, out ITypeName EventTypeName, out ICompiledType EventType);
if (!IsBooleanTypeAvailable && !IsEventTypeAvailable)
{
AddSourceError(new ErrorBooleanTypeMissing(node));
Success = false;
}
else
{
ICompiledType ContractType = ResolvedResult.At(0).ValueType;
if (!IsValidType(ContractType, IsBooleanTypeAvailable, BooleanType) && !IsValidType(ContractType, IsEventTypeAvailable, EventType))
{
AddSourceError(new ErrorInvalidExpression(BooleanExpression));
Success = false;
}
else
{
IResultException ResolvedException = new ResultException();
ResultException.Merge(ResolvedException, BooleanExpression.ResolvedException.Item);
ResultException.Merge(ResolvedException, Instructions.ResolvedException.Item);
data = ResolvedException;
}
}
}
return(Success);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IFunctionType node, object data)
{
IResultType CommonResults = (IResultType)data;
IClass EmbeddingClass = node.EmbeddingClass;
IObjectType BaseType = (IObjectType)node.BaseType;
ITypeName BaseTypeName = BaseType.ResolvedTypeName.Item;
ICompiledTypeWithFeature ResolvedBaseType = BaseType.ResolvedType.Item as ICompiledTypeWithFeature;
Debug.Assert(BaseType != null);
FunctionType.ResolveType(EmbeddingClass.TypeTable, BaseTypeName, BaseType, ResolvedBaseType, node.OverloadList, out ITypeName ResolvedTypeName, out IFunctionType ResolvedType);
node.ResolvedTypeName.Item = ResolvedTypeName;
node.ResolvedType.Item = ResolvedType;
}
/// <summary>
/// Gets the class type of an expression, if any.
/// </summary>
/// <param name="booleanOrEventExpression">A boolean or event expression.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="expressionClassType">The class type upon return, if successful.</param>
public static bool GetClassTypeOfExpression(IExpression booleanOrEventExpression, IErrorList errorList, out IClassType expressionClassType)
{
expressionClassType = null;
bool Result = false;
IClass EmbeddingClass = booleanOrEventExpression.EmbeddingClass;
IResultType ExpressionResult = booleanOrEventExpression.ResolvedResult.Item;
if (ExpressionResult.TryGetResult(out ICompiledType BooleanOrEventExpressionType) && BooleanOrEventExpressionType is IClassType AsClassType)
{
if (CheckForBooleanOrEventType(booleanOrEventExpression, AsClassType, errorList))
{
expressionClassType = AsClassType;
Result = true;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpCloneOfExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpCloneOfExpression(ICSharpContext context, ICloneOfExpression source)
: base(context, source)
{
SourceExpression = Create(context, (IExpression)source.Source);
IResultType SourceResult = SourceExpression.Source.ResolvedResult.Item;
Debug.Assert(SourceResult.Count > 0);
foreach (IExpressionType ExpressionType in SourceResult)
{
ICompiledType ClonedType = ExpressionType.ValueType;
ICSharpType Type = CSharpType.Create(context, ClonedType);
TypeList.Add(Type);
}
}
/// <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(IBinaryOperatorExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item4;
IFunctionFeature SelectedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item5;
IQueryOverload SelectedOverload = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item6;
IFeatureCall FeatureCall = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, IFunctionFeature, IQueryOverload, IFeatureCall>)data).Item7;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.SelectedFeature.Item = SelectedFeature;
node.SelectedOverload.Item = SelectedOverload;
node.FeatureCall.Item = FeatureCall;
}
/// <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(IBinaryOperatorExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 2);
IExpression LeftConstantSource = node.ConstantSourceList[0];
Debug.Assert(LeftConstantSource == node.LeftExpression);
IExpression RightConstantSource = node.ConstantSourceList[1];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(LeftConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant LeftExpressionConstant = LeftConstantSource.ExpressionConstant.Item;
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (LeftExpressionConstant != NeutralLanguageConstant.NotConstant && RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
Debug.Assert(node.ResolvedResult.IsAssigned);
IResultType ResolvedResult = node.ResolvedResult.Item;
if (ResolvedResult.Count == 1)
{
IExpressionType ConstantType = ResolvedResult.At(0);
bool IsBooleanTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType);
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
if (IsBooleanTypeAvailable && ConstantType.ValueType == BooleanType)
{
ExpressionConstant = new BooleanLanguageConstant();
}
else if (IsNumberTypeAvailable && ConstantType.ValueType == NumberType)
{
ExpressionConstant = new NumberLanguageConstant();
}
}
}
node.ExpressionConstant.Item = ExpressionConstant;
}
private bool IsForLoopTypeAvailable(IForLoopInstruction node)
{
bool IsBooleanTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType);
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
if (node.Variant.IsAssigned && !IsNumberTypeAvailable)
{
AddSourceError(new ErrorNumberTypeMissing(node));
return(false);
}
if (!IsBooleanTypeAvailable)
{
AddSourceError(new ErrorBooleanTypeMissing(node));
return(false);
}
IExpression WhileCondition = (IExpression)node.WhileCondition;
IResultType ResolvedResult = WhileCondition.ResolvedResult.Item;
IExpressionType ContractType = ResolvedResult.At(0);
if (ContractType.ValueType != BooleanType)
{
AddSourceError(new ErrorInvalidExpression(WhileCondition));
return(false);
}
bool Success = true;
if (node.Variant.IsAssigned)
{
IExpression VariantCondition = (IExpression)node.Variant.Item;
foreach (IExpressionType Item in VariantCondition.ResolvedResult.Item)
{
if (Item.ValueType != NumberType)
{
AddSourceError(new ErrorInvalidExpression(VariantCondition));
Success = false;
}
}
}
return(Success);
}
