/// <summary> /// Sets the style of type arguments. /// </summary> /// <param name="argumentStyle">The style of type arguments.</param> public void SetArgumentStyle(TypeArgumentStyles argumentStyle) { Debug.Assert(ArgumentStyle == (TypeArgumentStyles)(-1)); Debug.Assert(argumentStyle >= TypeArgumentStyles.None); ArgumentStyle = argumentStyle; }
/// <summary> /// Initializes a new instance of the <see cref="FeatureCall"/> class. /// </summary> /// <param name="parameterList">List of parameters from the selected overload.</param> /// <param name="resultList">List of results from the selected overload.</param> /// <param name="argumentList">Arguments of the call.</param> /// <param name="resolvedArgumentList">Resolved arguments of the call.</param> /// <param name="typeArgumentStyle">The argument passing style.</param> public FeatureCall(IList <IParameter> parameterList, IList <IParameter> resultList, IList <IArgument> argumentList, IList <IExpressionType> resolvedArgumentList, TypeArgumentStyles typeArgumentStyle) { ParameterList = parameterList; ResultList = resultList; ArgumentList = argumentList; ResolvedArgumentList = resolvedArgumentList; TypeArgumentStyle = typeArgumentStyle; }
private static bool GetArgumentPassingStyle(IList <IArgument> argumentList, out TypeArgumentStyles argumentStyle, IErrorList errorList) { argumentStyle = TypeArgumentStyles.None; foreach (IArgument Argument in argumentList) { bool IsHandled = false; switch (Argument) { case IPositionalArgument AsPositionalArgument: if (argumentStyle == TypeArgumentStyles.None) { argumentStyle = TypeArgumentStyles.Positional; } else if (argumentStyle == TypeArgumentStyles.Assignment) { errorList.AddError(new ErrorArgumentMixed(AsPositionalArgument)); return(false); } IsHandled = true; break; case IAssignmentArgument AsAssignmentArgument: if (argumentStyle == TypeArgumentStyles.None) { argumentStyle = TypeArgumentStyles.Assignment; } else if (argumentStyle == TypeArgumentStyles.Positional) { errorList.AddError(new ErrorArgumentMixed(AsAssignmentArgument)); return(false); } IsHandled = true; break; } Debug.Assert(IsHandled); } return(true); }
private bool IsTypeArgumentValid(ITypeArgument item, ref TypeArgumentStyles argumentStyle) { bool Success = true; bool IsHandled = false; if (item is IPositionalTypeArgument AsPositionalTypeArgument) { if (argumentStyle == TypeArgumentStyles.None) { argumentStyle = TypeArgumentStyles.Positional; } else if (argumentStyle == TypeArgumentStyles.Assignment) { AddSourceError(new ErrorTypeArgumentMixed(item)); Success = false; } IsHandled = true; } else if (item is IAssignmentTypeArgument AsAssignmentTypeArgument) { if (argumentStyle == TypeArgumentStyles.None) { argumentStyle = TypeArgumentStyles.Assignment; } else if (argumentStyle == TypeArgumentStyles.Positional) { AddSourceError(new ErrorTypeArgumentMixed(item)); Success = false; } IsHandled = true; } Debug.Assert(IsHandled); return(Success); }
/// <summary> /// Checks if actual arguments of a call conform to expected parameters. /// </summary> /// <param name="parameterTableList">The list of expected parameters.</param> /// <param name="arguments">The list of arguments.</param> /// <param name="argumentStyle">The argument-passing style.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="source">The source to use for errors.</param> /// <param name="selectedIndex">The selected index in the list of overloads upon return.</param> public static bool ArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, TypeArgumentStyles argumentStyle, IErrorList errorList, ISource source, out int selectedIndex) { if (parameterTableList == null) { throw new ArgumentNullException(nameof(parameterTableList)); } if (arguments == null) { throw new ArgumentNullException(nameof(arguments)); } if (errorList == null) { throw new ArgumentNullException(nameof(errorList)); } selectedIndex = -1; bool Result = false; bool IsHandled = false; switch (argumentStyle) { case TypeArgumentStyles.None: Result = NoneArgumentsConformToParameters(parameterTableList, arguments, errorList, source, out selectedIndex); IsHandled = true; break; case TypeArgumentStyles.Positional: Result = PositionalArgumentsConformToParameters(parameterTableList, arguments, errorList, source, out selectedIndex); IsHandled = true; break; case TypeArgumentStyles.Assignment: Result = AssignmentArgumentsConformToParameters(parameterTableList, arguments, errorList, source, out selectedIndex); IsHandled = true; break; } Debug.Assert(IsHandled); Debug.Assert(selectedIndex >= 0 || !Result); return(Result); }
/// <summary> /// Validate and merge a list of arguments. /// </summary> /// <param name="argumentList">The list of arguments.</param> /// <param name="mergedArgumentList">The merged result.</param> /// <param name="argumentStyle">The validated style.</param> /// <param name="errorList">List of errors found.</param> public static bool Validate(IList <IArgument> argumentList, List <IExpressionType> mergedArgumentList, out TypeArgumentStyles argumentStyle, IErrorList errorList) { if (argumentList == null) { throw new ArgumentNullException(nameof(argumentList)); } if (mergedArgumentList == null) { throw new ArgumentNullException(nameof(mergedArgumentList)); } if (errorList == null) { throw new ArgumentNullException(nameof(errorList)); } argumentStyle = TypeArgumentStyles.None; if (!GetArgumentPassingStyle(argumentList, out argumentStyle, errorList)) { return(false); } bool IsHandled = false; bool Success = true; switch (argumentStyle) { case TypeArgumentStyles.None: IsHandled = true; break; case TypeArgumentStyles.Positional: Success = ValidatePositionalStyle(argumentList, mergedArgumentList, errorList); IsHandled = true; break; case TypeArgumentStyles.Assignment: Success = ValidateAssignmentStyle(argumentList, mergedArgumentList, errorList); IsHandled = true; break; } Debug.Assert(IsHandled); return(Success); }
private static bool ResolveFeatureAsFunctionType(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, List <IExpressionType> mergedArgumentList, TypeArgumentStyles typeArgumentStyle, IFunctionType finalType, ref ResolvedExpression resolvedExpression) { // IScopeAttributeFeature is the case of an agent. IList <IArgument> ArgumentList = node.ArgumentList; IFunctionFeature AsFunctionFeature = resolvedFinalFeature as IFunctionFeature; IScopeAttributeFeature AsScopeAttributeFeature = resolvedFinalFeature as IScopeAttributeFeature; Debug.Assert(AsFunctionFeature != null || AsScopeAttributeFeature != null); IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); foreach (IQueryOverloadType Overload in finalType.OverloadList) { ParameterTableList.Add(Overload.ParameterTable); } int SelectedIndex; if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, typeArgumentStyle, errorList, node, out SelectedIndex)) { return(false); } resolvedExpression.SelectedOverloadType = finalType.OverloadList[SelectedIndex]; resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList); resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList); if (AsFunctionFeature != null) { Debug.Assert(AsFunctionFeature.OverloadList.Count == finalType.OverloadList.Count); Debug.Assert(AsFunctionFeature.ResolvedAgentType.IsAssigned); Debug.Assert(AsFunctionFeature.ResolvedAgentType.Item == finalType); resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex]; resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverload.ResultTable; resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverload.ParameterTable, resolvedExpression.SelectedOverload.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle); } else { resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverloadType.ResultTable; resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverloadType.ParameterTable, resolvedExpression.SelectedOverloadType.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle); } return(true); }
/// <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(IGenericType node, IDictionary <ISourceTemplate, object> dataList, out object data) { bool Success = true; data = null; IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier; Debug.Assert(ClassIdentifier.ValidText.IsAssigned); string ValidIdentifier = ClassIdentifier.ValidText.Item; IClass EmbeddingClass = node.EmbeddingClass; ISealableDictionary <string, IImportedClass> ImportedClassTable = EmbeddingClass.ImportedClassTable; ISealableDictionary <string, ICompiledType> ResolvedTable = new SealableDictionary <string, ICompiledType>(); ISealableDictionary <string, IObjectType> LocationTable = new SealableDictionary <string, IObjectType>(); if (!ImportedClassTable.ContainsKey(ValidIdentifier)) { AddSourceError(new ErrorUnknownIdentifier(ClassIdentifier, ValidIdentifier)); Success = false; } else { TypeArgumentStyles ArgumentStyle = TypeArgumentStyles.None; foreach (ITypeArgument Item in node.TypeArgumentList) { Success &= IsTypeArgumentValid(Item, ref ArgumentStyle); } IImportedClass Imported = ImportedClassTable[ValidIdentifier]; IClass BaseClass = Imported.Item; if (BaseClass.GenericList.Count == 0) { AddSourceError(new ErrorGenericClass(node, ValidIdentifier)); Success = false; } if (Success) { bool IsHandled = false; switch (ArgumentStyle) { case TypeArgumentStyles.None: case TypeArgumentStyles.Positional: Success = CheckPositionalTypeArgumentsValidity(node, BaseClass, ResolvedTable, LocationTable); IsHandled = true; break; case TypeArgumentStyles.Assignment: Success = CheckAssignmentTypeArgumentsValidity(node, BaseClass, ResolvedTable, LocationTable); IsHandled = true; break; } Debug.Assert(IsHandled); if (Success) { ClassType.ResolveType(EmbeddingClass.TypeTable, BaseClass, ResolvedTable, EmbeddingClass.ResolvedClassType.Item, out ITypeName ValidResolvedTypeName, out ICompiledType ValidResolvedType); data = new Tuple <IClass, TypeArgumentStyles, ISealableDictionary <string, ICompiledType>, ISealableDictionary <string, IObjectType>, ITypeName, ICompiledType>(BaseClass, ArgumentStyle, ResolvedTable, LocationTable, ValidResolvedTypeName, ValidResolvedType); } } } return(Success); }
private static bool ResolveCallProperty(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IPropertyType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; if (ArgumentList.Count > 0) { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } else { ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); IPropertyFeature Property = (IPropertyFeature)OperatorFeature; string PropertyName = ((IFeatureWithName)Property).EntityName.Text; resolvedExpression.ResolvedResult = new ResultType(callType.ResolvedEntityTypeName.Item, callType.ResolvedEntityType.Item, PropertyName); resolvedExpression.ResolvedException = new ResultException(); if (Property.GetterBody.IsAssigned) { IBody GetterBody = (IBody)Property.GetterBody.Item; resolvedExpression.ResolvedException = new ResultException(GetterBody.ExceptionIdentifierList); } selectedParameterList = new SealableList <IParameter>(); selectedResultList = new SealableList <IParameter>(); resolvedArgumentList = new List <IExpressionType>(); return(true); } }
private static bool ResolveCallFunction(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IFunctionType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); foreach (IQueryOverloadType Overload in callType.OverloadList) { ParameterTableList.Add(Overload.ParameterTable); } if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, argumentStyle, errorList, node, out int SelectedIndex)) { return(false); } IFunctionFeature AsFunctionFeature = OperatorFeature as IFunctionFeature; Debug.Assert(AsFunctionFeature != null); Debug.Assert(AsFunctionFeature.OverloadList.Count == callType.OverloadList.Count); resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex]; resolvedExpression.SelectedOverloadType = callType.OverloadList[SelectedIndex]; resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList); resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList); selectedParameterList = resolvedExpression.SelectedOverloadType.ParameterTable; selectedResultList = resolvedExpression.SelectedOverloadType.ResultTable; resolvedArgumentList = mergedArgumentList; return(true); }
private static bool ResolveCallClass(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; if (ArgumentList.Count > 0) { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } else { ICompiledFeature OperatorFeature = selectedPrecursor.Feature; ITypeName OperatorTypeName = OperatorFeature.ResolvedEffectiveTypeName.Item; ICompiledType OperatorType = OperatorFeature.ResolvedEffectiveType.Item; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); resolvedExpression.ResolvedResult = new ResultType(OperatorTypeName, OperatorType, string.Empty); resolvedExpression.ResolvedException = new ResultException(); selectedParameterList = new SealableList <IParameter>(); selectedResultList = new SealableList <IParameter>(); resolvedArgumentList = new List <IExpressionType>(); } return(true); }
private static bool ResolveCall(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); bool IsHandled = false; bool Success = false; switch (OperatorFeature) { case IAttributeFeature AsAttributeFeature: case ICreationFeature AsCreationFeature: case IProcedureFeature AsProcedureFeature: case IIndexerFeature AsIndexerFeature: errorList.AddError(new ErrorInvalidExpression(node)); IsHandled = true; break; case IConstantFeature AsConstantFeature: Success = ResolveCallClass(node, selectedPrecursor, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; case IFunctionFeature AsFunctionFeature: IFunctionType FunctionType = AsFunctionFeature.ResolvedAgentType.Item as IFunctionType; Debug.Assert(FunctionType != null); Success = ResolveCallFunction(node, selectedPrecursor, FunctionType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; case IPropertyFeature AsPropertyFeature: IPropertyType PropertyType = AsPropertyFeature.ResolvedAgentType.Item as IPropertyType; Debug.Assert(PropertyType != null); Success = ResolveCallProperty(node, selectedPrecursor, PropertyType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; } Debug.Assert(IsHandled); return(Success); }