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