public TypeNode Dispatch(ExpressionNode node, List <TypeNode> parameterTypes)
{
return(node switch
{
IBinaryNumberOperator n => _numberHelper.VisitBinaryNumOp(n, parameterTypes),
IBinaryBooleanOperator n => _booleanHelper.VisitBinaryBoolOp(n, parameterTypes),
IBinarySetOperator n => _setHelper.VisitBinarySetOp(n, parameterTypes),
SubsetExpression n => _setHelper.VisitSubset(n, parameterTypes),
SetExpression n => _setHelper.VisitSet(n, parameterTypes),
NotExpression n => _booleanHelper.VisitNot(n, parameterTypes),
FunctionCallExpression n => _declarationHelper.VisitFunctionCall(n, parameterTypes),
IdentifierExpression n => _declarationHelper.VisitIdentifier(n, parameterTypes),
IntegerLiteralExpression _ => _declarationHelper.VisitIntegerLiteral(),
RealLiteralExpression _ => _declarationHelper.VisitRealLiteral(),
BooleanLiteralExpression _ => _declarationHelper.VisitBooleanLiteral(),
StringLiteralExpression _ => _declarationHelper.VisitStringLiteral(),
EmptySetLiteralExpression _ => _declarationHelper.VisitEmptySetLiteral(),
AdditionExpression n => _commonOperatorHelper.VisitAddition(n, parameterTypes),
SubtractionExpression n => _commonOperatorHelper.VisitSubtraction(n, parameterTypes),
AbsoluteValueExpression n => _commonOperatorHelper.VisitAbsoluteValue(n, parameterTypes),
IRelationOperator n => _commonOperatorHelper.VisitRelationalOperator(n, parameterTypes),
IEquivalenceOperator n => _commonOperatorHelper.VisitEquivalenceOperator(n, parameterTypes),
NegativeExpression n => _numberHelper.VisitNegative(n, parameterTypes),
ElementExpression n => _commonOperatorHelper.VisitElement(n, parameterTypes),
ISetGraphField n => _commonOperatorHelper.VisitISetGraphField(n, parameterTypes),
IFunctionGraphField n => _commonOperatorHelper.VisitIFunctionGraphField(n, parameterTypes),
GraphExpression n => _commonOperatorHelper.VisitGraph(n, parameterTypes),
AnonymousFunctionExpression n => _declarationHelper.VisitAnonymousFunction(n, parameterTypes),
_ => throw new UnimplementedTypeCheckerException(node, "Dispatch"),
});
private SubsetExpression GetSubsetExpression(TypeEnum left, TypeEnum right)
{
ExpressionNode leftNode = GetSet();
ExpressionNode rightNode = GetSet();
var node = new SubsetExpression(leftNode, rightNode, 0, 0);
return(node);
}
public bool SubsetBoolean(SubsetExpression node, List <object> parameters)
{
ExpressionNode lhs = node.Children[0];
ExpressionNode rhs = node.Children[1];
Set subset = _interpreter.DispatchSet(lhs, parameters);
Set superset = _interpreter.DispatchSet(rhs, parameters);
return(subset.Elements.IsSubsetOf(superset.Elements));
}
public TypeNode VisitSubset(SubsetExpression node, List <TypeNode> parameterTypes)
{
TypeNode left = _getType(node.Children[0], parameterTypes);
TypeNode right = _getType(node.Children[1], parameterTypes);
if (!IsSet(left.Type) || !IsSet(right.Type))
{
throw new UnmatchableTypesException((Node)node, left.Type, right.Type, "boolean");
}
return(new TypeNode(TypeEnum.Boolean, 0, 0));
}
public void SubsetBoolean_GivenSetAndSet_CorrectValueReturned(int[] a, int[] b, bool expected)
{
Set lhsValue = GetSetWith1DElements(a);
Set rhsValue = GetSetWith1DElements(b);
SetExpression lhs = GetSetInit();
SetExpression rhs = GetSetInit();
SubsetExpression expression = new SubsetExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
DispatchSetForParent(lhsValue, lhs, parent);
DispatchSetForParent(rhsValue, rhs, parent);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.SubsetBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
