/// <summary> /// Checks that a result of a list of overloads conform to a base type. /// </summary> /// <param name="overloadList">The list of overloads.</param> /// <param name="index">Index of the result in the possible results.</param> /// <param name="baseType">The base type.</param> /// <param name="location">The location where to report errors.</param> /// <param name="errorList">The list of errors found.</param> public static bool JoinedResultCheck(IList <IQueryOverloadType> overloadList, int index, ICompiledType baseType, ISource location, IErrorList errorList) { bool Success = true; IList <IParameter> SameIndexList = new List <IParameter>(); foreach (IQueryOverloadType Overload in overloadList) { ISealableList <IParameter> ResultTable = Overload.ResultTable; if (index < ResultTable.Count) { SameIndexList.Add(ResultTable[index]); } } for (int i = 0; i < SameIndexList.Count; i++) { IParameter CurrentParameter = SameIndexList[i]; ICompiledType CurrentParameterType = CurrentParameter.ResolvedParameter.ResolvedEffectiveType.Item; if (!ObjectType.TypeConformToBase(CurrentParameterType, baseType, isConversionAllowed: false)) { errorList.AddError(new ErrorNonConformingType(location)); Success = false; } } return(Success); }
private static bool DisjoinedParameterCheck(IList <ICommandOverloadType> overloadList, int index, IErrorList errorList) { IList <IParameter> SameIndexList = new List <IParameter>(); foreach (ICommandOverloadType Overload in overloadList) { ISealableList <IParameter> ParameterTable = Overload.ParameterTable; if (index < ParameterTable.Count) { SameIndexList.Add(ParameterTable[index]); } } bool Success = true; for (int i = 0; i < SameIndexList.Count && Success; i++) { IParameter Parameter1 = SameIndexList[i]; ICompiledType ParameterType1 = Parameter1.ResolvedParameter.ResolvedEffectiveType.Item; for (int j = i + 1; j < SameIndexList.Count && Success; j++) { IParameter Parameter2 = SameIndexList[j]; ICompiledType ParameterType2 = Parameter2.ResolvedParameter.ResolvedEffectiveType.Item; Success &= DisjoinedParameterCheck(Parameter1, Parameter2, errorList); Success &= DisjoinedParameterCheck(Parameter2, Parameter1, errorList); } } 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(IIndexerType node, object data) { IClassType BaseType = ((Tuple <IClassType, ISealableList <IParameter> >)data).Item1; ISealableList <IParameter> ParameterTable = ((Tuple <IClassType, ISealableList <IParameter> >)data).Item2; IClass EmbeddingClass = node.EmbeddingClass; IObjectType BaseTypeItem = (IObjectType)node.BaseType; IObjectType EntityTypeItem = (IObjectType)node.EntityType; Debug.Assert(node.ParameterTable.Count == 0); node.ParameterTable.AddRange(ParameterTable); node.ParameterTable.Seal(); ITypeName BaseTypeName = BaseTypeItem.ResolvedTypeName.Item; ITypeName EntityTypeName = EntityTypeItem.ResolvedTypeName.Item; ICompiledType EntityType = EntityTypeItem.ResolvedType.Item; #if COVERAGE string TypeString = node.ToString(); Debug.Assert(!node.IsReference); Debug.Assert(node.IsValue); #endif IndexerType.ResolveType(EmbeddingClass.TypeTable, BaseTypeName, BaseType, EntityTypeName, EntityType, node.IndexerKind, node.IndexParameterList, node.ParameterEnd, node.GetRequireList, node.GetEnsureList, node.GetExceptionIdentifierList, node.SetRequireList, node.SetEnsureList, node.SetExceptionIdentifierList, out ITypeName ResolvedTypeName, out ICompiledType ResolvedType); node.ResolvedTypeName.Item = ResolvedTypeName; node.ResolvedType.Item = ResolvedType; }
private static void GetCommonResultType(IList <IQueryOverloadType> overloadList, int index, out ITypeName resultTypeName, out ICompiledType resultType) { IList <IParameter> SameIndexList = new List <IParameter>(); foreach (IQueryOverloadType Overload in overloadList) { ISealableList <IParameter> ResultTable = Overload.ResultTable; if (index < ResultTable.Count) { SameIndexList.Add(ResultTable[index]); } } IParameter SelectedParameter = SameIndexList[0]; ITypeName SelectedParameterTypeName = SelectedParameter.ResolvedParameter.ResolvedEffectiveTypeName.Item; ICompiledType SelectedParameterType = SelectedParameter.ResolvedParameter.ResolvedEffectiveType.Item; for (int i = 1; i < SameIndexList.Count; i++) { IParameter CurrentParameter = SameIndexList[i]; ITypeName CurrentParameterTypeName = CurrentParameter.ResolvedParameter.ResolvedEffectiveTypeName.Item; ICompiledType CurrentParameterType = CurrentParameter.ResolvedParameter.ResolvedEffectiveType.Item; if (ObjectType.TypeConformToBase(SelectedParameterType, CurrentParameterType, isConversionAllowed: false)) { SelectedParameter = CurrentParameter; SelectedParameterTypeName = CurrentParameterTypeName; SelectedParameterType = CurrentParameterType; } } resultTypeName = SelectedParameterTypeName; resultType = SelectedParameterType; }
/// <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(ICommandOverload node, object data) { IClass EmbeddingClass = node.EmbeddingClass; ISealableDictionary <string, IScopeAttributeFeature> CheckedScope = ((Tuple <ISealableDictionary <string, IScopeAttributeFeature>, ISealableList <IParameter> >)data).Item1; ISealableList <IParameter> ParameterTable = ((Tuple <ISealableDictionary <string, IScopeAttributeFeature>, ISealableList <IParameter> >)data).Item2; node.ParameterTable.AddRange(ParameterTable); node.ParameterTable.Seal(); IBody CommandBody = (IBody)node.CommandBody; ICommandOverloadType AssociatedType = new CommandOverloadType(node.ParameterList, BaseNode.ParameterEndStatus.Closed, CommandBody.RequireList, CommandBody.EnsureList, CommandBody.ExceptionIdentifierList); AssociatedType.ParameterTable.AddRange(ParameterTable); AssociatedType.ParameterTable.Seal(); node.ResolvedAssociatedType.Item = AssociatedType; node.LocalScope.Merge(CheckedScope); node.LocalScope.Seal(); node.FullScope.Merge(node.LocalScope); ScopeHolder.RecursiveAdd(node.FullScope, node.InnerScopes); EmbeddingClass.BodyList.Add((IBody)node.CommandBody); EmbeddingClass.CommandOverloadList.Add(node); }
private static IList <ICompiledType> GetTypesConvertibleTo(IClassType type) { ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = type.FeatureTable; ISealableDictionary <IFeatureName, IFunctionFeature> ConversionToTable = type.BaseClass.ConversionToTable; IList <ICompiledType> Result = new List <ICompiledType>(); foreach (KeyValuePair <IFeatureName, IFunctionFeature> Entry in ConversionToTable) { IFunctionFeature Feature = Entry.Value; foreach (IQueryOverload Overload in Feature.OverloadList) { ISealableList <IParameter> ParameterTable = Overload.ParameterTable; Debug.Assert(ParameterTable.IsSealed); Debug.Assert(ParameterTable.Count == 0); ISealableList <IParameter> ResultTable = Overload.ResultTable; Debug.Assert(ResultTable.IsSealed); Debug.Assert(ResultTable.Count == 1); IParameter OverloadResult = ResultTable[0]; Debug.Assert(OverloadResult.ResolvedParameter.ResolvedEffectiveType.IsAssigned); ICompiledType OverloadResultType = OverloadResult.ResolvedParameter.ResolvedEffectiveType.Item; Result.Add(OverloadResultType); } } return(Result); }
/// <summary> /// Checks if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { IList ItemList = GetSourceObject(node, out bool IsInterrupted); IList <ISealableList <TValue> > ReadyValueList = new List <ISealableList <TValue> >(); for (int i = 0; i < ItemList.Count && !IsInterrupted; i++) { TItem Item = (TItem)ItemList[i]; ISealableList <TValue> Value = ItemProperty.GetValue(Item) as ISealableList <TValue>; Debug.Assert(Value != null); if (Value.IsSealed) { ReadyValueList.Add(Value); } else { IsInterrupted = true; } } if (IsInterrupted) { data = null; return(false); } else { data = ReadyValueList; return(true); } }
private static bool PositionalArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, IErrorList errorList, ISource source, out int selectedIndex) { ISealableList <IParameter> SelectedOverload = null; selectedIndex = -1; int MaximumAllowedArgumentCount = -1; for (int i = 0; i < parameterTableList.Count; i++) { PositionalArgumentMatching(parameterTableList, arguments, i, ref MaximumAllowedArgumentCount, ref SelectedOverload, ref selectedIndex); } if (MaximumAllowedArgumentCount >= 0 && MaximumAllowedArgumentCount < arguments.Count) { errorList.AddError(new ErrorTooManyArguments(source, arguments.Count, MaximumAllowedArgumentCount)); return(false); } if (SelectedOverload == null) { errorList.AddError(new ErrorInvalidExpression(source)); return(false); } Debug.Assert(SelectedOverload.Count >= arguments.Count); 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(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> /// True if the destination value has been set; /// </summary> /// <param name="node">The node for which the value is to be checked.</param> public override bool IsSet(TSource node) { ISealableList <TItem> ListValue = GetDestinationObject(node); Debug.Assert(ListValue == GetDestinationObject((ISource)node)); return(ListValue.IsSealed); }
/// <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(ICommandOverloadType node, object data) { IClass EmbeddingClass = node.EmbeddingClass; ISealableList <IParameter> ParameterTable = (ISealableList <IParameter>)data; Debug.Assert(node.ParameterTable.Count == 0); node.ParameterTable.AddRange(ParameterTable); node.ParameterTable.Seal(); }
/// <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> /// 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> /// 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 if a node source is ready. /// </summary> /// <param name="node">The node for which the value is checked.</param> /// <param name="data">Optional data returned to the caller.</param> public override bool IsReady(TSource node, out object data) { data = null; bool Result = false; ISealableList <TValue> Value = GetSourceObject(node, out bool IsInterrupted) as ISealableList <TValue>; Debug.Assert(Value != null || IsInterrupted); if (!IsInterrupted && Value != null && Value.IsSealed) { data = Value; Result = true; } return(Result); }
private static void PositionalArgumentMatching(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, int i, ref int maximumAllowedArgumentCount, ref ISealableList <IParameter> selectedOverload, ref int selectedIndex) { ISealableList <IParameter> OverloadParameterList = parameterTableList[i]; int j; bool IsMatching = true; for (j = 0; j < arguments.Count && j < OverloadParameterList.Count && IsMatching; j++) { ICompiledType ArgumentType = arguments[j].ValueType; IParameter OverloadParameter = OverloadParameterList[j]; ICompiledType ParameterType = TypeOfPositionalParameter(OverloadParameter); IsMatching &= ObjectType.TypeConformToBase(ArgumentType, ParameterType, isConversionAllowed: true); } if (IsMatching) { if (maximumAllowedArgumentCount < OverloadParameterList.Count) { maximumAllowedArgumentCount = OverloadParameterList.Count; } for (; j < OverloadParameterList.Count && IsMatching; j++) { IParameter OverloadParameter = OverloadParameterList[j]; IsMatching &= OverloadParameter.ResolvedParameter.DefaultValue.IsAssigned; } } if (IsMatching && j >= arguments.Count) { bool IsBetter = false; if (selectedOverload != null) { IsBetter = SelectMatchingOverload(OverloadParameterList, selectedOverload); } if (selectedOverload == null || IsBetter) { selectedOverload = OverloadParameterList; selectedIndex = i; } } }
/// <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; }
private static bool SelectMatchingOverload(ISealableList <IParameter> overloadParameterList, ISealableList <IParameter> selectedOverload) { bool IsBetter = false; for (int j = 0; j < overloadParameterList.Count && j < selectedOverload.Count; j++) { IParameter OverloadParameter = overloadParameterList[j]; ICompiledType OverloadParameterType = TypeOfPositionalParameter(OverloadParameter); IParameter SelectedParameter = selectedOverload[j]; ICompiledType SelectedParameterType = TypeOfPositionalParameter(SelectedParameter); if (OverloadParameterType != SelectedParameterType) { IsBetter |= ObjectType.TypeConformToBase(OverloadParameterType, SelectedParameterType, isConversionAllowed: false); } } return(IsBetter); }
/// <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> /// 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; } }
/// <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(IQueryOverloadType node, object data) { IClass EmbeddingClass = node.EmbeddingClass; ISealableList <IParameter> ParameterTable = ((Tuple <ISealableList <IParameter>, ISealableList <IParameter> >)data).Item1; ISealableList <IParameter> ResultTable = ((Tuple <ISealableList <IParameter>, ISealableList <IParameter> >)data).Item2; Debug.Assert(node.ParameterTable.Count == 0); Debug.Assert(node.ResultTable.Count == 0); node.ParameterTable.AddRange(ParameterTable); node.ParameterTable.Seal(); node.ResultTable.AddRange(ResultTable); node.ResultTable.Seal(); foreach (IParameter Parameter in ResultTable) { Debug.Assert(Parameter.ResolvedParameter.ResolvedEffectiveType.IsAssigned); node.ConformantResultTable.Add(Parameter.ResolvedParameter.ResolvedEffectiveType.Item); } }
/// <summary> /// Checks the validity of an assignment of a source to a destination, with arguments. /// </summary> /// <param name="parameterTableList">The list of expected parameters.</param> /// <param name="resultTableList">The list of results.</param> /// <param name="argumentList">The list of actual arguments.</param> /// <param name="sourceExpression">Expression in the assignment.</param> /// <param name="destinationType">The expected type for the expression.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="source">The source to use when reporting errors.</param> /// <param name="featureCall">Details of the feature call.</param> public static bool CheckAssignmentConformance(IList <ISealableList <IParameter> > parameterTableList, IList <ISealableList <IParameter> > resultTableList, IList <IArgument> argumentList, IExpression sourceExpression, ICompiledType destinationType, IErrorList errorList, ISource source, out IFeatureCall featureCall) { featureCall = null; IResultType SourceResult = sourceExpression.ResolvedResult.Item; List <IExpressionType> MergedArgumentList = new List <IExpressionType>(); if (!Argument.Validate(argumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList)) { return(false); } if (!Argument.ArgumentsConformToParameters(parameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, source, out int SelectedIndex)) { return(false); } if (SourceResult.Count != 1) { errorList.AddError(new ErrorInvalidExpression(sourceExpression)); return(false); } ISealableList <IParameter> SelectedParameterList = parameterTableList[SelectedIndex]; ISealableList <IParameter> SelectedResultList = resultTableList[SelectedIndex]; ICompiledType SourceType = SourceResult.At(0).ValueType; if (!ObjectType.TypeConformToBase(SourceType, destinationType, errorList, sourceExpression, isConversionAllowed: true)) { errorList.AddError(new ErrorInvalidExpression(sourceExpression)); return(false); } featureCall = new FeatureCall(SelectedParameterList, SelectedResultList, argumentList, MergedArgumentList, TypeArgumentStyle); return(true); }
/// <summary> /// Adds to a list of constant sources from a list of arguments. /// </summary> /// <param name="argumentList">The list of arguments.</param> /// <param name="constantSourceList">The list of constant sources.</param> public static void AddConstantArguments(IList <IArgument> argumentList, ISealableList <IExpression> constantSourceList) { Debug.Assert(argumentList.Count > 0); foreach (IArgument Argument in argumentList) { IExpression ArgumentSource = null; switch (Argument) { case IPositionalArgument AsPositionalArgument: ArgumentSource = (IExpression)AsPositionalArgument.Source; break; case IAssignmentArgument AsAssignmentArgument: ArgumentSource = (IExpression)AsAssignmentArgument.Source; break; } Debug.Assert(ArgumentSource != null); constantSourceList.Add(ArgumentSource); } }
/// <summary> /// Finds the matching nodes of a <see cref="IUnaryNotExpression"/>. /// </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 constant value upon return, if any.</param> public static bool ResolveCompilerReferences(IUnaryNotExpression 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 RightExpression = (IExpression)node.RightExpression; IClass EmbeddingClass = node.EmbeddingClass; bool IsRightClassType = Expression.GetClassTypeOfExpression(RightExpression, errorList, out IClassType RightExpressionClassType); if (!IsRightClassType) { return(false); } Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType); Expression.IsLanguageTypeAvailable(LanguageClasses.Event.Guid, node, out ITypeName EventTypeName, out ICompiledType EventType); Debug.Assert(RightExpressionClassType == BooleanType || RightExpressionClassType == EventType); node.SetIsEventExpression(RightExpressionClassType != BooleanType); constantSourceList.Add(RightExpression); resolvedResult = new ResultType(BooleanTypeName, BooleanType, string.Empty); ResultException.Propagate(RightExpression.ResolvedException, out resolvedException); #if COVERAGE Debug.Assert(node.IsComplex); #endif return(true); }
/// <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); } }
private static bool AssignmentArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, IErrorList errorList, ISource source, out int selectedIndex) { ISealableList <IParameter> SelectedOverload = null; selectedIndex = -1; for (int i = 0; i < parameterTableList.Count; i++) { ISealableList <IParameter> OverloadParameterList = parameterTableList[i]; List <IParameter> UnassignedParameters = new List <IParameter>(OverloadParameterList); bool IsMatching = true; for (int j = 0; j < arguments.Count && IsMatching; j++) { ICompiledType ArgumentType = arguments[j].ValueType; string ArgumentName = arguments[j].Name; OnceReference <IParameter> MatchingParameter = new OnceReference <IParameter>(); foreach (IParameter p in OverloadParameterList) { if (p.Name == ArgumentName) { MatchingParameter.Item = p; break; } } if (!MatchingParameter.IsAssigned) { errorList.AddError(new ErrorArgumentNameMismatch(source, ArgumentName)); return(false); } IParameter OverloadParameter = MatchingParameter.Item; UnassignedParameters.Remove(OverloadParameter); ICompiledType ParameterType = OverloadParameter.ResolvedParameter.ResolvedEffectiveType.Item; IsMatching &= ObjectType.TypeConformToBase(ArgumentType, ParameterType, isConversionAllowed: true); } foreach (IParameter OverloadParameter in UnassignedParameters) { IsMatching &= OverloadParameter.ResolvedParameter.DefaultValue.IsAssigned; } if (IsMatching) { Debug.Assert(SelectedOverload == null); SelectedOverload = OverloadParameterList; selectedIndex = i; } } if (SelectedOverload == null) { errorList.AddError(new ErrorInvalidExpression(source)); return(false); } else { return(true); } }