/// <summary> /// Compares two overloads. /// </summary> /// <param name="overload1">The first overload.</param> /// <param name="overload2">The second overload.</param> public static bool QueryOverloadsHaveIdenticalSignature(IQueryOverloadType overload1, IQueryOverloadType overload2) { bool IsIdentical = true; IsIdentical &= overload1.ParameterList.Count == overload2.ParameterList.Count; IsIdentical &= overload1.ParameterEnd == overload2.ParameterEnd; IsIdentical &= overload1.ResultList.Count == overload2.ResultList.Count; for (int i = 0; i < overload1.ParameterList.Count && i < overload2.ParameterList.Count; i++) { Debug.Assert(overload1.ParameterList[i].ValidEntity.IsAssigned); Debug.Assert(overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(overload2.ParameterList[i].ValidEntity.IsAssigned); Debug.Assert(overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item, overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item); } for (int i = 0; i < overload1.ResultList.Count && i < overload2.ResultList.Count; i++) { Debug.Assert(overload1.ResultList[i].ValidEntity.IsAssigned); Debug.Assert(overload1.ResultList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(overload2.ResultList[i].ValidEntity.IsAssigned); Debug.Assert(overload2.ResultList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(overload1.ResultList[i].ValidEntity.Item.ResolvedEffectiveType.Item, overload2.ResultList[i].ValidEntity.Item.ResolvedEffectiveType.Item); } IsIdentical &= Assertion.IsAssertionListEqual(overload1.RequireList, overload2.RequireList); IsIdentical &= Assertion.IsAssertionListEqual(overload1.EnsureList, overload2.EnsureList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(overload1.ExceptionIdentifierList, overload2.ExceptionIdentifierList); return(IsIdentical); }
/// <summary> /// Initializes the feature precursor hierarchy. /// </summary> /// <param name="context">The initialization context.</param> public override void InitHierarchy(ICSharpContext context) { if (Instance.OriginalPrecursor.IsAssigned) { IPrecursorInstance Item = Instance.OriginalPrecursor.Item; ICompiledFeature PrecursorFeature = Item.Precursor.Feature; OriginalPrecursor = context.GetFeature(PrecursorFeature) as ICSharpFunctionFeature; Debug.Assert(OriginalPrecursor != null); IList <ICSharpOverload> PrecursorOverloadList = OriginalPrecursor.OverloadList; foreach (ICSharpQueryOverload Overload in OverloadList) { IQueryOverloadType ResolvedAssociatedType = Overload.Source.ResolvedAssociatedType.Item; ICSharpQueryOverload ParentPrecursorOverload = null; foreach (ICSharpQueryOverload PrecursorOverload in PrecursorOverloadList) { IQueryOverloadType PrecursorResolvedAssociatedType = PrecursorOverload.Source.ResolvedAssociatedType.Item; if (ObjectType.QueryOverloadConformToBase(ResolvedAssociatedType, PrecursorResolvedAssociatedType, ErrorList.Ignored, ErrorList.NoLocation)) { Debug.Assert(ParentPrecursorOverload == null); ParentPrecursorOverload = PrecursorOverload; } } Debug.Assert(ParentPrecursorOverload != null); Overload.SetPrecursor(ParentPrecursorOverload); } } }
/// <summary> /// Initializes a new instance of the <see cref="ErrorOverloadParameterMismatchConformance"/> class. /// </summary> /// <param name="source">The error location.</param> /// <param name="derivedType">The derived type</param> /// <param name="baseType">The base type.</param> public ErrorOverloadParameterMismatchConformance(ISource source, IQueryOverloadType derivedType, ICompiledType baseType) : base(source) { DerivedParameterList = derivedType.ParameterList; DerivedParameterEnd = derivedType.ParameterEnd; BaseType = baseType; }
/// <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); }
private static bool FunctionTypeConformToIndexerTypeOverloads(IQueryOverloadType derivedOverload, IIndexerType baseType, IErrorList errorList, ISource sourceLocation) { bool Result = true; Result &= derivedOverload.ParameterList.Count == baseType.IndexParameterList.Count && derivedOverload.ResultList.Count == 1 && derivedOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed; for (int i = 0; i < derivedOverload.ParameterList.Count && i < baseType.IndexParameterList.Count; i++) { IEntityDeclaration BaseParameter = baseType.IndexParameterList[i]; IEntityDeclaration DerivedParameter = derivedOverload.ParameterList[i]; Debug.Assert(DerivedParameter.ValidEntity.IsAssigned); Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false); } IEntityDeclaration OverloadResult = derivedOverload.ResultList[0]; Debug.Assert(baseType.ResolvedEntityType.IsAssigned); Debug.Assert(OverloadResult.ValidEntity.IsAssigned); Debug.Assert(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(baseType.ResolvedEntityType.Item, OverloadResult.ValidEntity.Item.ResolvedEffectiveType.Item, ErrorList.Ignored, ErrorList.NoLocation, isConversionAllowed: false); Result &= ExceptionListConformToBase(derivedOverload.ExceptionIdentifierList, baseType.GetExceptionIdentifierList, errorList, sourceLocation); return(Result); }
/// <summary> /// Creates an instance of a class type, or reuse an existing instance. /// </summary> /// <param name="instancingClassType">The class type to instanciate.</param> /// <param name="resolvedTypeName">The proposed type instance name.</param> /// <param name="resolvedType">The proposed type instance.</param> public void InstanciateType(ICompiledTypeWithFeature instancingClassType, ref ITypeName resolvedTypeName, ref ICompiledType resolvedType) { bool IsNewInstance = false; ITypeName InstancedBaseTypeName = ResolvedBaseTypeName.Item; ICompiledType InstancedBaseType = ResolvedBaseType.Item; InstancedBaseType.InstanciateType(instancingClassType, ref InstancedBaseTypeName, ref InstancedBaseType); IsNewInstance |= InstancedBaseType != ResolvedBaseType.Item; IList <IQueryOverloadType> InstancedOverloadList = new List <IQueryOverloadType>(); foreach (IQueryOverloadType Overload in OverloadList) { IQueryOverloadType InstancedOverload = Overload; QueryOverloadType.InstanciateQueryOverloadType(instancingClassType, ref InstancedOverload); InstancedOverloadList.Add(InstancedOverload); IsNewInstance |= InstancedOverload != Overload; } if (IsNewInstance) { ISealableDictionary <ITypeName, ICompiledType> TypeTable = instancingClassType.GetTypeTable(); ResolveType(TypeTable, InstancedBaseTypeName, (IObjectType)BaseType, (ICompiledTypeWithFeature)InstancedBaseType, InstancedOverloadList, out resolvedTypeName, out IFunctionType ResolvedFunctionType); resolvedType = ResolvedFunctionType; } }
/// <summary> /// Gets the most common type of all overloads. /// </summary> /// <param name="overloadList">The list of overloads.</param> public static IResultType CommonResultType(IList <IQueryOverloadType> overloadList) { int MaxResult = 0; int MaxResultIndex = 0; for (int i = 0; i < overloadList.Count; i++) { IQueryOverloadType Overload = overloadList[i]; if (MaxResult < Overload.ResultTable.Count) { MaxResult = Overload.ResultTable.Count; MaxResultIndex = i; } } IList <IExpressionType> ResultList = new List <IExpressionType>(); for (int i = 0; i < MaxResult; i++) { GetCommonResultType(overloadList, i, out ITypeName ResultTypeName, out ICompiledType ResultType); Debug.Assert(i < overloadList[MaxResultIndex].ResultTypeList.Count); IExpressionType NewExpressionType = new ExpressionType(ResultTypeName, ResultType, overloadList[MaxResultIndex].ResultTypeList[i].Name); ResultList.Add(NewExpressionType); } return(new ResultType(ResultList)); }
private static bool QueryOverloadHasPropertyConformingBase(IQueryOverloadType derivedOverload, IPropertyType baseType, IErrorList errorList, ISource sourceLocation) { bool Result = true; if (derivedOverload.ParameterList.Count > 0 || derivedOverload.ResultList.Count != 1 || derivedOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed) { errorList.AddError(new ErrorOverloadParameterMismatchConformance(sourceLocation, derivedOverload, baseType)); Result = false; } if (derivedOverload.ResultList.Count == 1) { IEntityDeclaration OverloadResult = derivedOverload.ResultList[0]; Debug.Assert(baseType.ResolvedEntityType.IsAssigned); Debug.Assert(OverloadResult.ValidEntity.IsAssigned); Debug.Assert(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(baseType.ResolvedEntityType.Item, OverloadResult.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false); } Result &= ExceptionListConformToBase(derivedOverload.ExceptionIdentifierList, baseType.GetExceptionIdentifierList, errorList, sourceLocation); return(Result); }
/// <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(IQueryOverload node, object data) { Debug.Assert(node.ResolvedAssociatedType.IsAssigned); IQueryOverloadType OverloadType = node.ResolvedAssociatedType.Item; Debug.Assert(OverloadType.ConformantResultTable.IsSealed); node.CompleteConformantResultTable.AddRange(OverloadType.ConformantResultTable); node.CompleteConformantResultTable.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(IQueryOverload node, object data) { node.ConformantResultTable.Seal(); Debug.Assert(node.ResolvedAssociatedType.IsAssigned); IQueryOverloadType AssociatedType = node.ResolvedAssociatedType.Item; Debug.Assert(!AssociatedType.ConformantResultTable.IsSealed); AssociatedType.ConformantResultTable.Seal(); }
private static bool IndexerTypeConformToFunctionType(IIndexerType derivedType, IFunctionType baseType, IErrorList errorList, ISource sourceLocation) { bool Result = true; Debug.Assert(derivedType.ResolvedBaseType.IsAssigned); Debug.Assert(baseType.ResolvedBaseType.IsAssigned); Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false); if (derivedType.IndexerKind == BaseNode.UtilityType.WriteOnly) { errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType)); Result = false; } if (baseType.OverloadList.Count > 1) { errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType)); Result = false; } IQueryOverloadType SingleOverload = baseType.OverloadList[0]; if (SingleOverload.ParameterList.Count != derivedType.IndexParameterList.Count || SingleOverload.ResultList.Count != 1 || SingleOverload.ParameterEnd != derivedType.ParameterEnd) { errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType)); Result = false; } for (int i = 0; i < SingleOverload.ParameterList.Count && i < derivedType.IndexParameterList.Count; i++) { IEntityDeclaration BaseParameter = SingleOverload.ParameterList[i]; IEntityDeclaration DerivedParameter = derivedType.IndexParameterList[i]; Debug.Assert(DerivedParameter.ValidEntity.IsAssigned); Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false); } IEntityDeclaration OverloadResult = SingleOverload.ResultList[0]; Debug.Assert(OverloadResult.ValidEntity.IsAssigned); Debug.Assert(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(derivedType.ResolvedEntityType.IsAssigned); Result &= TypeConformToBase(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.Item, derivedType.ResolvedEntityType.Item, errorList, sourceLocation, isConversionAllowed: false); Result &= ExceptionListConformToBase(derivedType.GetExceptionIdentifierList, SingleOverload.ExceptionIdentifierList, errorList, sourceLocation); return(Result); }
/// <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> /// Checks that a query overload conforms to another. /// </summary> /// <param name="derivedType">The derived type.</param> /// <param name="baseType">The base type.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="sourceLocation">The location for reporting errors.</param> public static bool QueryOverloadConformToBase(IQueryOverloadType derivedType, IQueryOverloadType baseType, IErrorList errorList, ISource sourceLocation) { bool Result = true; if (baseType.ParameterList.Count != derivedType.ParameterList.Count || baseType.ParameterEnd != derivedType.ParameterEnd) { errorList.AddError(new ErrorParameterMismatchConformance(sourceLocation, derivedType, baseType)); Result = false; } if (baseType.ResultList.Count != derivedType.ResultList.Count) { errorList.AddError(new ErrorResultMismatchConformance(sourceLocation, derivedType, baseType)); Result = false; } for (int i = 0; i < baseType.ParameterList.Count && i < derivedType.ParameterList.Count; i++) { IEntityDeclaration BaseParameter = baseType.ParameterList[i]; IEntityDeclaration DerivedParameter = derivedType.ParameterList[i]; Debug.Assert(DerivedParameter.ValidEntity.IsAssigned); Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.IsAssigned); Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false); } for (int i = 0; i < baseType.ResultList.Count && i < derivedType.ResultList.Count; i++) { IEntityDeclaration BaseResult = baseType.ResultList[i]; IEntityDeclaration DerivedResult = derivedType.ResultList[i]; Debug.Assert(BaseResult.ValidEntity.IsAssigned); Debug.Assert(BaseResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(DerivedResult.ValidEntity.IsAssigned); Debug.Assert(DerivedResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Result &= TypeConformToBase(DerivedResult.ValidEntity.Item.ResolvedEffectiveType.Item, BaseResult.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false); } Result &= ExceptionListConformToBase(derivedType.ExceptionIdentifierList, baseType.ExceptionIdentifierList, errorList, sourceLocation); return(Result); }
/// <summary> /// Checks if a matching function and overload exists in a type table. /// </summary> /// <param name="typeTable">The table of existing types.</param> /// <param name="overload">The overload to check.</param> /// <param name="overloadList">The list of other overloads in the candidate function type.</param> public static bool IsQueryOverloadMatching(ISealableDictionary <ITypeName, ICompiledType> typeTable, IQueryOverloadType overload, IList <IQueryOverloadType> overloadList) { bool IsMatching = false; for (int i = 0; i < overloadList.Count && !IsMatching; i++) { IQueryOverloadType Item = overloadList[i]; IsMatching = true; IsMatching &= IsParametersMatching(overload, Item); IsMatching &= IsResultsMatching(overload, Item); IsMatching &= Assertion.IsAssertionListEqual(overload.RequireList, Item.RequireList); IsMatching &= Assertion.IsAssertionListEqual(overload.EnsureList, Item.EnsureList); IsMatching &= ExceptionHandler.IdenticalExceptionSignature(overload.ExceptionIdentifierList, Item.ExceptionIdentifierList); } return(IsMatching); }
private static bool IsResultsMatching(IQueryOverloadType overload1, IQueryOverloadType overload2) { bool IsMatching = true; IsMatching &= overload1.ResultList.Count == overload2.ResultList.Count; for (int i = 0; i < overload1.ResultList.Count && i < overload2.ResultList.Count; i++) { IScopeAttributeFeature OverloadAttribute1 = overload1.ResultList[i].ValidEntity.Item; IScopeAttributeFeature OverloadAttribute2 = overload2.ResultList[i].ValidEntity.Item; IsMatching &= OverloadAttribute1.ResolvedEffectiveType.Item == OverloadAttribute2.ResolvedEffectiveType.Item; IsMatching &= IsResultNameMatching(OverloadAttribute1.EntityName.Text, OverloadAttribute2.EntityName.Text); IsMatching &= IsDefaultValueMatching(OverloadAttribute1.DefaultValue, OverloadAttribute2.DefaultValue); } return(IsMatching); }
/// <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) { ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant; Debug.Assert(node.ConstantSourceList.Count == 1); IExpression RightConstantSource = node.ConstantSourceList[0]; Debug.Assert(RightConstantSource == node.RightExpression); Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned); ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item; if (RightExpressionConstant != NeutralLanguageConstant.NotConstant) { Debug.Assert(node.SelectedOverloadType.IsAssigned); IQueryOverloadType SelectedOverloadType = node.SelectedOverloadType.Item; if (SelectedOverloadType.ResultTable.Count == 1) { IParameter OverloadResult = SelectedOverloadType.ResultTable[0]; Debug.Assert(OverloadResult.ResolvedParameter.ResolvedEffectiveType.IsAssigned); ICompiledType ResultType = OverloadResult.ResolvedParameter.ResolvedEffectiveType.Item; if (Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType) && ResultType == BooleanType) { ExpressionConstant = new BooleanLanguageConstant(); } else if (Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType) && ResultType == NumberType) { ExpressionConstant = new NumberLanguageConstant(); } else if (Expression.IsLanguageTypeAvailable(LanguageClasses.Character.Guid, node, out ITypeName CharacterTypeName, out ICompiledType CharacterType) && ResultType == CharacterType) { ExpressionConstant = new CharacterLanguageConstant(); }
/// <summary> /// Initializes a new instance of the <see cref="ErrorResultMismatchConformance"/> class. /// </summary> /// <param name="source">The error location.</param> /// <param name="derivedType">The derived type</param> /// <param name="baseType">The base type.</param> public ErrorResultMismatchConformance(ISource source, IQueryOverloadType derivedType, IQueryOverloadType baseType) : base(source) { DerivedResultList = derivedType.ResultList; BaseResultList = baseType.ResultList; }
/// <summary> /// Initializes a new instance of the <see cref="CSharpBinaryOperatorExpression"/> class. /// </summary> /// <param name="source">The Easly expression from which the C# expression is created.</param> /// <param name="context">The creation context.</param> protected CSharpBinaryOperatorExpression(ICSharpContext context, IBinaryOperatorExpression source) : base(context, source) { LeftExpression = Create(context, (IExpression)source.LeftExpression); RightExpression = Create(context, (IExpression)source.RightExpression); Operator = context.GetFeature(source.SelectedFeature.Item) as ICSharpFunctionFeature; Debug.Assert(Operator != null); IResultType ResolvedLeftResult = LeftExpression.Source.ResolvedResult.Item; IExpressionType PreferredLeftResult = ResolvedLeftResult.Preferred; Debug.Assert(PreferredLeftResult != null); if (PreferredLeftResult.ValueType is IClassType AsClassType) { if (AsClassType.BaseClass.ClassGuid == LanguageClasses.Number.Guid || AsClassType.BaseClass.ClassGuid == LanguageClasses.Integer.Guid) { IsCallingNumberFeature = true; } } if (IsCallingNumberFeature) { IResultType ResolvedRightResult = RightExpression.Source.ResolvedResult.Item; Debug.Assert(ResolvedRightResult.Count == 1); } else { if (!LeftExpression.IsSingleResult) { IResultType LeftResultType = LeftExpression.Source.ResolvedResult.Item; LeftNameList = new List <string>(); LeftResultNameIndex = LeftResultType.ResultNameIndex; for (int i = 0; i < LeftResultType.Count; i++) { IExpressionType DestinationType = LeftResultType.At(i); string Text = DestinationType.Name; LeftNameList.Add(Text); } } if (!RightExpression.IsSingleResult) { IResultType RightResultType = RightExpression.Source.ResolvedResult.Item; RightNameList = new List <string>(); RightResultNameIndex = RightResultType.ResultNameIndex; for (int i = 0; i < RightResultType.Count; i++) { IExpressionType DestinationType = RightResultType.At(i); string Text = DestinationType.Name; RightNameList.Add(Text); } } } FeatureCall = new CSharpFeatureCall(context, Source.FeatureCall.Item); Debug.Assert(Source.SelectedOverload.IsAssigned); IQueryOverload Overload = Source.SelectedOverload.Item; IQueryOverloadType ResolvedAssociatedType = Overload.ResolvedAssociatedType.Item; SelectedOverloadType = CSharpQueryOverloadType.Create(context, ResolvedAssociatedType, Operator.Owner); }
private string QueryOverloadType2CSharpString(string delegateName, IQueryOverloadType overload) { // TODO return(delegateName); }
/// <summary> /// Finds the matching nodes of a <see cref="IBinaryOperatorExpression"/>. /// </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> /// <param name="selectedFeature">The matching feature upon return.</param> /// <param name="selectedOverload">The matching overload in <paramref name="selectedFeature"/> upon return.</param> /// <param name="featureCall">Details of the feature call.</param> public static bool ResolveCompilerReferences(IBinaryOperatorExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out IFunctionFeature selectedFeature, out IQueryOverload selectedOverload, out IFeatureCall featureCall) { resolvedResult = null; resolvedException = null; constantSourceList = new SealableList <IExpression>(); expressionConstant = NeutralLanguageConstant.NotConstant; selectedFeature = null; selectedOverload = null; featureCall = null; IExpression LeftExpression = (IExpression)node.LeftExpression; IIdentifier Operator = (IIdentifier)node.Operator; IExpression RightExpression = (IExpression)node.RightExpression; IResultType LeftResult = LeftExpression.ResolvedResult.Item; if (LeftResult.TryGetResult(out ICompiledType LeftExpressionType)) { if (LeftExpressionType is IClassType AsClassType) { string OperatorName = Operator.ValidText.Item; ISealableDictionary <IFeatureName, IFeatureInstance> LeftFeatureTable = AsClassType.FeatureTable; if (!FeatureName.TableContain(LeftFeatureTable, OperatorName, out IFeatureName Key, out IFeatureInstance Value)) { errorList.AddError(new ErrorUnknownIdentifier(Operator, OperatorName)); return(false); } Debug.Assert(Value.Feature != null); ICompiledFeature OperatorFeature = Value.Feature; ICompiledType OperatorType = OperatorFeature.ResolvedAgentType.Item; if (OperatorFeature is IFunctionFeature AsFunctionFeature && OperatorType is FunctionType AsFunctionType) { IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); foreach (IQueryOverloadType Overload in AsFunctionType.OverloadList) { ParameterTableList.Add(Overload.ParameterTable); } IResultType RightResult = RightExpression.ResolvedResult.Item; if (!Argument.ArgumentsConformToParameters(ParameterTableList, RightResult.ToList(), TypeArgumentStyles.Positional, errorList, Operator, out int SelectedIndex)) { return(false); } IQueryOverloadType SelectedOverloadType = AsFunctionType.OverloadList[SelectedIndex]; resolvedResult = new ResultType(SelectedOverloadType.ResultTypeList); selectedFeature = AsFunctionFeature; selectedOverload = AsFunctionFeature.OverloadList[SelectedIndex]; IArgument FirstArgument = new PositionalArgument(RightExpression); IList <IArgument> ArgumentList = new List <IArgument>() { FirstArgument }; List <IExpressionType> MergedArgumentList = new List <IExpressionType>(); bool IsArgumentValid = Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList); Debug.Assert(IsArgumentValid); featureCall = new FeatureCall(SelectedOverloadType.ParameterTable, SelectedOverloadType.ResultTable, ArgumentList, MergedArgumentList, TypeArgumentStyle); resolvedException = new ResultException(SelectedOverloadType.ExceptionIdentifierList); constantSourceList.Add(LeftExpression); constantSourceList.Add(RightExpression); } else { errorList.AddError(new ErrorInvalidOperator(Operator, OperatorName)); return(false); } } else { errorList.AddError(new ErrorInvalidExpression(LeftExpression)); return(false); } }
/// <summary> /// Finds or creates an overload type with the corresponding parameters. /// </summary> /// <param name="instancingClassType">The type attempting to find the overload type.</param> /// <param name="instancedOverload">The new overload type upon return if not found.</param> public static void InstanciateQueryOverloadType(ICompiledTypeWithFeature instancingClassType, ref IQueryOverloadType instancedOverload) { bool IsNewInstance = false; IList <IEntityDeclaration> InstancedParameterList = new List <IEntityDeclaration>(); foreach (IEntityDeclaration Parameter in instancedOverload.ParameterList) { ITypeName InstancedParameterTypeName = Parameter.ValidEntity.Item.ResolvedEffectiveTypeName.Item; ICompiledType InstancedParameterType = Parameter.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedParameterType.InstanciateType(instancingClassType, ref InstancedParameterTypeName, ref InstancedParameterType); IEntityDeclaration InstancedParameter = new EntityDeclaration(Parameter, InstancedParameterTypeName, InstancedParameterType); IName ParameterName = (IName)Parameter.EntityName; IScopeAttributeFeature NewEntity; if (Parameter.DefaultValue.IsAssigned) { // The default value has already been checked and validated. bool IsCreated = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType, (IExpression)Parameter.DefaultValue.Item, ErrorList.Ignored, out NewEntity); Debug.Assert(IsCreated); } else { NewEntity = ScopeAttributeFeature.Create(Parameter, ParameterName.ValidText.Item, InstancedParameterTypeName, InstancedParameterType); } InstancedParameter.ValidEntity.Item = NewEntity; InstancedParameterList.Add(InstancedParameter); if (InstancedParameterType != Parameter.ValidEntity.Item.ResolvedEffectiveType.Item) { IsNewInstance = true; } } IList <IEntityDeclaration> InstancedResultList = new List <IEntityDeclaration>(); foreach (IEntityDeclaration Result in instancedOverload.ResultList) { ITypeName InstancedResultTypeName = Result.ValidEntity.Item.ResolvedEffectiveTypeName.Item; ICompiledType InstancedResultType = Result.ValidEntity.Item.ResolvedEffectiveType.Item; InstancedResultType.InstanciateType(instancingClassType, ref InstancedResultTypeName, ref InstancedResultType); IEntityDeclaration InstancedResult = new EntityDeclaration(Result, InstancedResultTypeName, InstancedResultType); IName ResultName = (IName)Result.EntityName; IScopeAttributeFeature NewEntity; if (Result.DefaultValue.IsAssigned) { // The default value has already been checked and validated. bool IsCreated = ScopeAttributeFeature.Create(Result, ResultName.ValidText.Item, InstancedResultTypeName, InstancedResultType, (IExpression)Result.DefaultValue.Item, ErrorList.Ignored, out NewEntity); Debug.Assert(IsCreated); } else { NewEntity = ScopeAttributeFeature.Create(Result, ResultName.ValidText.Item, InstancedResultTypeName, InstancedResultType); } InstancedResult.ValidEntity.Item = NewEntity; InstancedResultList.Add(InstancedResult); if (InstancedResultType != Result.ValidEntity.Item.ResolvedEffectiveType.Item) { IsNewInstance = true; } } if (IsNewInstance) { IQueryOverloadType NewOverloadInstance = new QueryOverloadType(InstancedParameterList, instancedOverload.ParameterEnd, InstancedResultList, instancedOverload.RequireList, instancedOverload.EnsureList, instancedOverload.ExceptionIdentifierList); foreach (IEntityDeclaration Item in InstancedParameterList) { string ValidName = Item.ValidEntity.Item.ValidFeatureName.Item.Name; NewOverloadInstance.ParameterTable.Add(new Parameter(ValidName, Item.ValidEntity.Item)); } foreach (IEntityDeclaration Item in InstancedResultList) { string ValidName = Item.ValidEntity.Item.ValidFeatureName.Item.Name; NewOverloadInstance.ResultTable.Add(new Parameter(ValidName, Item.ValidEntity.Item)); } instancedOverload = NewOverloadInstance; } }
/// <summary> /// Finds the matching nodes of a <see cref="IUnaryOperatorExpression"/>. /// </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> /// <param name="selectedFeature">The matching feature upon return.</param> /// <param name="selectedOverload">The matching overload in <paramref name="selectedFeature"/> upon return.</param> /// <param name="selectedOverloadType">The matching overload type upon return.</param> public static bool ResolveCompilerReferences(IUnaryOperatorExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out IFunctionFeature selectedFeature, out IQueryOverload selectedOverload, out IQueryOverloadType selectedOverloadType) { resolvedResult = null; resolvedException = null; constantSourceList = new SealableList <IExpression>(); expressionConstant = NeutralLanguageConstant.NotConstant; selectedFeature = null; selectedOverload = null; selectedOverloadType = null; IIdentifier Operator = (IIdentifier)node.Operator; string ValidText = Operator.ValidText.Item; IExpression RightExpression = (IExpression)node.RightExpression; IResultType RightResult = RightExpression.ResolvedResult.Item; if (!RightResult.TryGetResult(out ICompiledType RightExpressionType)) { errorList.AddError(new ErrorInvalidExpression(RightExpression)); return(false); } if (RightExpressionType is IClassType AsClassType) { ISealableDictionary <IFeatureName, IFeatureInstance> RightFeatureTable = AsClassType.FeatureTable; if (!FeatureName.TableContain(RightFeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Value)) { errorList.AddError(new ErrorUnknownIdentifier(RightExpression, ValidText)); return(false); } ICompiledFeature OperatorFeature = Value.Feature; ICompiledType OperatorType = OperatorFeature.ResolvedAgentType.Item; if (OperatorFeature is IFunctionFeature AsFunctionFeature && OperatorType is IFunctionType AsFunctionType) { IList <IQueryOverloadType> OperatorOverloadList = AsFunctionType.OverloadList; int SelectedOperatorIndex = -1; for (int i = 0; i < OperatorOverloadList.Count; i++) { IQueryOverloadType Overload = OperatorOverloadList[i]; if (Overload.ParameterList.Count == 0 && Overload.ResultList.Count == 1) { SelectedOperatorIndex = i; break; } } if (SelectedOperatorIndex < 0) { errorList.AddError(new ErrorInvalidOperator(Operator, ValidText)); return(false); } resolvedResult = Feature.CommonResultType(AsFunctionType.OverloadList); selectedFeature = AsFunctionFeature; selectedOverload = AsFunctionFeature.OverloadList[SelectedOperatorIndex]; selectedOverloadType = OperatorOverloadList[SelectedOperatorIndex]; resolvedException = new ResultException(selectedOverloadType.ExceptionIdentifierList); constantSourceList.Add(RightExpression); } else { errorList.AddError(new ErrorInvalidOperator(Operator, ValidText)); return(false); } }