public void GreaterThanOrEqualToIntegerNegativeAssertion()
{
string expression = "${MyVariable>=12}";
string key = "MyVariable";
string val = "11";
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsFalse((bool)resolved_exp.ResolvedValue);
}
public void AdditionAssertion()
{
string expression = "${MyVariable+24}";
string key = "MyVariable";
int val = 12;
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((int)resolved_exp.ResolvedValue, (12 + 24));
}
public void CompoundPrecedenceAssertion()
{
string expression = "${MyVariable+24*8}";
string key = "MyVariable";
string val = "48";
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((string)resolved_exp.ResolvedValue, ("48192"));
}
public void CompoundOverridePrecedenceAssertion()
{
string expression = "${(MyVariable+24)*8}";
string key = "MyVariable";
int val = 48;
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((int)resolved_exp.ResolvedValue, ((48 + 24) * 8));
}
public void TernaryOperationAssertion()
{
string expression = "${MyVariable==48?'y' + 'e' + 's':'n' + 'o'}";
string key = "MyVariable";
int val = 48;
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((string)resolved_exp.ResolvedValue, "yes");
}
public void LeftSideStringAdditionAssertion()
{
string expression = "${'abc'+MyVariable}";
string key = "MyVariable";
string val = "def";
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((string)resolved_exp.ResolvedValue, "abc" + "def");
}
public void CompoundSubtractionAssertion()
{
string expression = "${MyVariable-24-8}";
string key = "MyVariable";
int val = 48;
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((int)resolved_exp.ResolvedValue, (48 - 24 - 8));
}
public void ListRightSideStringAdditionAssertion()
{
string expression = "${MyVariable[0]+'def'}";
string key = "MyVariable";
string[] val = { "abc" };
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((string)resolved_exp.ResolvedValue, "abc" + "def");
}
public void ListSubtractionAssertion()
{
string expression = "${MyVariable[0]-24}";
string key = "MyVariable";
int[] val = { 12 };
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.AreEqual((int)resolved_exp.ResolvedValue, (12 - 24));
}
public void ListGreaterThanOrEqualToIntegerPositiveAssertion()
{
string expression = "${MyVariable[0]>=12}";
string key = "MyVariable";
int[] val = { 13 };
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsTrue((bool)resolved_exp.ResolvedValue);
}
public void EqualsStringPositiveAssertion()
{
string expression = "${MyVariable=='asdf'}";
string key = "MyVariable";
string val = "asdf";
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsTrue((bool)(resolved_exp.ResolvedValue));
}
public void EqualsIntegerPositiveAssertion()
{
string expression = "${MyVariable==10}";
string key = "MyVariable";
int val = 10;
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsTrue((bool)resolved_exp.ResolvedValue);
}
public void MixedDataLiteralEquivilencyEvaluations(int dataIntVal, double dataDoubleVal, string expression, bool expectedResult)
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject dataObject
= new SimpleExpressionResolverDataObject(dataIntVal, "Top Object", dataDoubleVal);
string key = "foo";
dc.RegisterDataItem(key, dataObject);
ResolvedExpression result = Engine.ResolveExpression(expression, dc);
Assert.AreEqual(ResolvedExpression.booleanType, result.ResolvedType);
Assert.AreEqual(expectedResult, result.ResolvedValue, "Expression did not evalute: " + expression);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IOldExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedExpression">The result of the search.</param>
public static bool ResolveCompilerReferences(IOldExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression)
{
resolvedExpression = new ResolvedExpression();
IClass EmbeddingClass = node.EmbeddingClass;
IQualifiedName Query = (IQualifiedName)node.Query;
IList <IIdentifier> ValidPath = Query.ValidPath.Item;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType))
{
errorList.AddError(new ErrorBooleanTypeMissing(node));
return(false);
}
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
Debug.Assert(LocalScope != null);
if (node.EmbeddingBody == null && node.EmbeddingAssertion == null)
{
errorList.AddError(new ErrorInvalidOldExpression(node));
return(false);
}
if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, errorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute))
{
return(false);
}
if (FinalFeature == null)
{
errorList.AddError(new ErrorInvalidOldExpression(node));
return(false);
}
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item);
resolvedExpression.ResolvedFinalFeature = FinalFeature;
resolvedExpression.ResolvedResult = new ResultType(FinalTypeName, FinalType, string.Empty);
resolvedExpression.ResolvedException = new ResultException();
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
public void ListEqualsIntegerNegativeAssertion()
{
string expression = "${MyVariable[0]==10}";
string key = "MyVariable";
int[] val = { 11 };
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsFalse((bool)resolved_exp.ResolvedValue);
}
public void ListEqualsStringNegativeAssertion()
{
string expression = "${MyVariable=='asdf'}";
string key = "MyVariable";
string[] val = { "asdfsa" };
DataContext dc = new DataContext();
dc.RegisterDataItem(key, val);
ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc);
Assert.IsFalse((bool)(resolved_exp.ResolvedValue));
}
/// <summary>
/// 解析原始表达式（OriginExpression），生成 ResolvedExpression，
/// 调用此函数之前请先调用 RegistryElements<T> 注册表达式对象
/// </summary>
async System.Threading.Tasks.Task Resolve()
{
var elems = OriginExpression.Split(new[] { "==", "}.", "+", "-", "*", "/", "^", "(", ")", " " }, StringSplitOptions.RemoveEmptyEntries);
var elements = new List <ExpressionElement>();
await System.Threading.Tasks.Task.Run(() =>
{
foreach (var elem in elems)
{
//elem = elem + "}";
foreach (var expelement in ElementCollection)
{
var arr = elem.Split('{');
if (expelement.Type == arr[0])
{
var e = expelement.Clone() as ExpressionElement;
e.Original = arr[1];
e.DoProcess();
if (e.Original != e.Value.ToString() &&
e.Value != null)
{
var reg = new Regex($"{e.Type}{{{e.Original}}}");
ResolvedExpression = reg.Replace(ResolvedExpression, e.Value.ToString(), 1);
}
elements.Add(e);
}
}
}
// 检查表达式是否计算完成
if (ResolvedExpression.IndexOf("{") < 0)
{
// 生成表达式计算结果
var expression = ResolvedExpression.Replace("==", "=");
DataTable table = new DataTable();
var value = table.Compute(expression, "");
if ((int)value == 1)
{
Result = true;
}
}
});
}
/// <summary>
/// Evaluates the current LoopConditionalExpression.
/// Returns the result
/// </summary>
/// <returns></returns>
protected bool EvaluateLoopConditionalExpressionPasses()
{
if (String.IsNullOrEmpty(LoopConditionalExpression))
{
return(true);
}
ResolvedExpression resolvedExpression = Engine.ResolveExpression(LoopConditionalExpression, MyDataContext);
if (resolvedExpression.HasException())
{
return(false);
}
if (resolvedExpression.ResolvedType != ResolvedExpression.booleanType)
{
return(false);
}
return((bool)resolvedExpression.ResolvedValue);
}
/*
* Two precursor index expressions cannot be compared because it happens only when comparing different features, and there can be only one indexer.
* public static bool IsExpressionEqual(IPrecursorIndexExpression expression1, IPrecursorIndexExpression expression2)
* {
* bool Result = true;
*
* if (expression1.AncestorType.IsAssigned && expression2.AncestorType.IsAssigned)
* {
* IObjectType AncestorType1 = (IObjectType)expression1.AncestorType;
* IObjectType AncestorType2 = (IObjectType)expression2.AncestorType;
*
* Debug.Assert(AncestorType1.ResolvedType.IsAssigned);
* Debug.Assert(AncestorType2.ResolvedType.IsAssigned);
*
* Result &= AncestorType1.ResolvedType.Item == AncestorType2.ResolvedType.Item;
* }
*
* Result &= expression1.AncestorType.IsAssigned == expression2.AncestorType.IsAssigned;
* Result &= Argument.IsArgumentListEqual(expression1.ArgumentList, expression2.ArgumentList);
*
* return Result;
* }
*/
/// <summary>
/// Finds the matching nodes of a <see cref="IPrecursorIndexExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedExpression">The result of the search.</param>
public static bool ResolveCompilerReferences(IPrecursorIndexExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression)
{
resolvedExpression = new ResolvedExpression();
IOptionalReference <BaseNode.IObjectType> AncestorType = node.AncestorType;
IList <IArgument> ArgumentList = node.ArgumentList;
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[FeatureName.IndexerFeatureName];
if (!Instance.FindPrecursor(node.AncestorType, errorList, node, out IFeatureInstance SelectedPrecursor))
{
return(false);
}
resolvedExpression.SelectedPrecursor = SelectedPrecursor;
if (!ResolveSelectedPrecursor(node, SelectedPrecursor, errorList, ref resolvedExpression))
{
return(false);
}
}
else
{
errorList.AddError(new ErrorIndexPrecursorNotAllowedOutsideIndexer(node));
return(false);
}
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Evaluates the current IfConditionExpression.
/// Returns the result
/// </summary>
/// <returns></returns>
protected bool EvaluateIfCondition()
{
if (String.IsNullOrEmpty(IfConditionExpression))
{
return(false);
}
ResolvedExpression resolvedExpression = Engine.ResolveExpression(IfConditionExpression, MyDataContext);
if (resolvedExpression.HasException())
{
return(false);
}
if (resolvedExpression.ResolvedType != ResolvedExpression.booleanType)
{
return(false);
}
else
{
return((bool)resolvedExpression.ResolvedValue);
}
}
/// <summary>
/// Finds the matching nodes of a <see cref="IQueryExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedExpression">The result of the search.</param>
public static bool ResolveCompilerReferences(IQueryExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression)
{
resolvedExpression = new ResolvedExpression();
IQualifiedName Query = (IQualifiedName)node.Query;
IList <IArgument> ArgumentList = node.ArgumentList;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
IList <IIdentifier> ValidPath = Query.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))
{
return(false);
}
Debug.Assert(FinalFeature != null || FinalDiscrete != null);
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
if (FinalFeature != null)
{
resolvedExpression.ResolvedFinalFeature = FinalFeature;
return(ResolveFeature(node, errorList, FinalFeature, FinalTypeName, FinalType, ref resolvedExpression));
}
else
{
Debug.Assert(FinalDiscrete != null);
resolvedExpression.ResolvedFinalDiscrete = FinalDiscrete;
return(ResolveDiscrete(node, errorList, FinalDiscrete, ref resolvedExpression));
}
}
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);
}
private static bool ResolveDiscrete(IQueryExpression node, IErrorList errorList, IDiscrete resolvedFinalDiscrete, ref ResolvedExpression resolvedExpression)
{
// This is enforced by the caller.
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
Debug.Assert(IsNumberTypeAvailable);
resolvedExpression.ResolvedResult = new ResultType(NumberTypeName, NumberType, resolvedFinalDiscrete.ValidDiscreteName.Item.Name);
resolvedExpression.ResolvedException = new ResultException();
if (resolvedFinalDiscrete.NumericValue.IsAssigned)
{
IExpression NumericValue = (IExpression)resolvedFinalDiscrete.NumericValue.Item;
resolvedExpression.ConstantSourceList.Add(NumericValue);
}
else
{
resolvedExpression.ExpressionConstant = new DiscreteLanguageConstant(resolvedFinalDiscrete);
}
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
return(true);
}
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);
}
private static bool ResolveFeature(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, ITypeName finalTypeName, ICompiledType finalType, ref ResolvedExpression resolvedExpression)
{
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
IQualifiedName Query = (IQualifiedName)node.Query;
IList <IArgument> ArgumentList = node.ArgumentList;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
IList <IIdentifier> ValidPath = Query.ValidPath.Item;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList))
{
return(false);
}
IIdentifier LastIdentifier = ValidPath[ValidPath.Count - 1];
string ValidText = LastIdentifier.ValidText.Item;
bool IsHandled = false;
bool Success = true;
switch (finalType)
{
case IFunctionType AsFunctionType:
if (!ResolveFeatureAsFunctionType(node, errorList, resolvedFinalFeature, MergedArgumentList, TypeArgumentStyle, AsFunctionType, ref resolvedExpression))
{
return(false);
}
IsHandled = true;
break;
case IProcedureType AsProcedureType:
case IIndexerType AsIndexerType:
errorList.AddError(new ErrorInvalidExpression(node));
Success = false;
IsHandled = true;
break;
case IPropertyType AsPropertyType:
resolvedExpression.ResolvedResult = new ResultType(AsPropertyType.ResolvedEntityTypeName.Item, AsPropertyType.ResolvedEntityType.Item, ValidText);
resolvedExpression.ResolvedException = new ResultException(AsPropertyType.GetExceptionIdentifierList);
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
case IClassType AsClassType:
case ITupleType AsTupleType:
resolvedExpression.ResolvedResult = new ResultType(finalTypeName, finalType, ValidText);
resolvedExpression.ResolvedException = new ResultException();
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
case IFormalGenericType AsFormalGenericType:
resolvedExpression.ResolvedResult = new ResultType(finalTypeName, AsFormalGenericType, ValidText);
resolvedExpression.ResolvedException = new ResultException();
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
if (!Success)
{
return(false);
}
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item);
IsHandled = false;
switch (resolvedFinalFeature)
{
case IConstantFeature AsConstantFeature:
IExpression ConstantValue = (IExpression)AsConstantFeature.ConstantValue;
resolvedExpression.ConstantSourceList.Add(ConstantValue);
IsHandled = true;
break;
case IFunctionFeature AsFunctionFeature:
Argument.AddConstantArguments(node, resolvedExpression.ResolvedResult, ArgumentList, resolvedExpression.ConstantSourceList, out ILanguageConstant ExpressionConstant);
resolvedExpression.ExpressionConstant = ExpressionConstant;
IsHandled = true;
break;
case IAttributeFeature AsAttributeFeature:
case IPropertyFeature AsPropertyFeature:
case IScopeAttributeFeature AsScopeAttributeFeature:
resolvedExpression.ExpressionConstant = Expression.GetDefaultConstant(node, resolvedExpression.ResolvedResult);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
return(true);
}
private static bool ResolveSelectedPrecursor(IPrecursorIndexExpression node, IFeatureInstance selectedPrecursor, IErrorList errorList, ref ResolvedExpression resolvedExpression)
{
IList <IArgument> ArgumentList = node.ArgumentList;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList))
{
return(false);
}
IIndexerFeature OperatorFeature = selectedPrecursor.Feature as IIndexerFeature;
Debug.Assert(OperatorFeature != null);
IIndexerType OperatorType = OperatorFeature.ResolvedAgentType.Item as IIndexerType;
Debug.Assert(OperatorType != null);
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ParameterTableList.Add(OperatorType.ParameterTable);
IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >();
ResultTableList.Add(new SealableList <IParameter>());
int SelectedIndex;
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, node, out SelectedIndex))
{
return(false);
}
resolvedExpression.ResolvedResult = new ResultType(OperatorType.ResolvedEntityTypeName.Item, OperatorType.ResolvedEntityType.Item, string.Empty);
resolvedExpression.ResolvedException = new ResultException(OperatorType.GetExceptionIdentifierList);
resolvedExpression.FeatureCall = new FeatureCall(ParameterTableList[SelectedIndex], ResultTableList[SelectedIndex], ArgumentList, MergedArgumentList, TypeArgumentStyle);
resolvedExpression.ResolvedFinalFeature = OperatorFeature;
Argument.AddConstantArguments(ArgumentList, resolvedExpression.ConstantSourceList);
return(true);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IIndexQueryExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedExpression">The result of the search.</param>
public static bool ResolveCompilerReferences(IIndexQueryExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression)
{
resolvedExpression = new ResolvedExpression();
IExpression IndexedExpression = (IExpression)node.IndexedExpression;
IList <IArgument> ArgumentList = node.ArgumentList;
IClass EmbeddingClass = node.EmbeddingClass;
IResultType ResolvedIndexerResult = IndexedExpression.ResolvedResult.Item;
IExpressionType PreferredIndexerResult = ResolvedIndexerResult.Preferred;
ICompiledType IndexedExpressionType;
if (PreferredIndexerResult == null)
{
errorList.AddError(new ErrorInvalidExpression(node));
return(false);
}
else
{
IndexedExpressionType = PreferredIndexerResult.ValueType;
}
if (IndexedExpressionType is IClassType AsClassType)
{
IClass IndexedBaseClass = AsClassType.BaseClass;
ISealableDictionary <IFeatureName, IFeatureInstance> IndexedFeatureTable = IndexedBaseClass.FeatureTable;
if (!IndexedFeatureTable.ContainsKey(FeatureName.IndexerFeatureName))
{
errorList.AddError(new ErrorMissingIndexer(node));
return(false);
}
IFeatureInstance IndexerInstance = IndexedFeatureTable[FeatureName.IndexerFeatureName];
IIndexerFeature Indexer = (IndexerFeature)IndexerInstance.Feature;
IIndexerType AsIndexerType = (IndexerType)Indexer.ResolvedAgentType.Item;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ParameterTableList.Add(AsIndexerType.ParameterTable);
IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >();
ResultTableList.Add(new SealableList <IParameter>());
int SelectedIndex;
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, node, out SelectedIndex))
{
return(false);
}
resolvedExpression.ResolvedFinalFeature = Indexer;
resolvedExpression.ResolvedResult = new ResultType(AsIndexerType.ResolvedEntityTypeName.Item, AsIndexerType.ResolvedEntityType.Item, string.Empty);
resolvedExpression.ResolvedException = new ResultException(AsIndexerType.GetExceptionIdentifierList);
resolvedExpression.FeatureCall = new FeatureCall(ParameterTableList[SelectedIndex], ResultTableList[SelectedIndex], ArgumentList, MergedArgumentList, TypeArgumentStyle);
Argument.AddConstantArguments(ArgumentList, resolvedExpression.ConstantSourceList);
}
else
{
errorList.AddError(new ErrorInvalidExpression(node));
return(false);
}
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
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 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 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);
}
