public void TupleAssignment()
{
Expression expression = parseStatement("(a -> int, b -> FakeClass) = (4, p);");
TupleDeclarationAssignmentExpression a = assertTypeAndCast <TupleDeclarationAssignmentExpression>(expression);
Assert.AreEqual(2, a.names.members.Count);
Assert.AreEqual("a", a.names.members[0].name);
Assert.AreEqual("int", a.names.members[0].typeName.name);
Assert.IsNotInstanceOfType(a.names.members[0].typeName, typeof(GenericTypeName));
Assert.AreEqual("b", a.names.members[1].name);
Assert.AreEqual("FakeClass", a.names.members[1].typeName.name);
Assert.IsNotInstanceOfType(a.names.members[1].typeName, typeof(GenericTypeName));
TupleDefinitionExpression d = assertTypeAndCast <TupleDefinitionExpression>(a.values);
Assert.AreEqual(2, d.members.Count);
IntegralLiteralExpression e = assertTypeAndCast <IntegralLiteralExpression>(d.members[0]);
VariableReferenceExpression f = assertTypeAndCast <VariableReferenceExpression>(d.members[1]);
Assert.AreEqual(4, e.value);
Assert.AreEqual("p", f.name);
}
public static Expression functionDeclaration(Parser p, Expression left, Token t)
{
if (left is VariableReferenceExpression)
{
Expression arguments = roundBacketRouter(p, t);
if (arguments is VariableDeclarationExpression)
{
arguments = new TupleDeclarationExpression(new List <VariableDeclarationExpression>()
{
arguments as VariableDeclarationExpression
});
}
if (arguments is TupleDeclarationExpression)
{
p.skip(TokenType.Dash);
p.skip(TokenType.RightAngleBracket);
TypeName returnType = DashParslets.getTypeName(p);
Expression body = p.parseExpression(0);
if (body is BlockExpression)
{
return(new FunctionExpression((left as VariableReferenceExpression).name,
arguments as TupleDeclarationExpression,
returnType,
body as BlockExpression));
}
else
{
throw new Exception("Function has invalid body!");
}
}
else
{
if (!(arguments is TupleDefinitionExpression))
{
arguments = new TupleDefinitionExpression(new List <Expression>()
{
arguments
});
}
return(new FunctionCallExpression((left as VariableReferenceExpression).name, arguments as TupleDefinitionExpression));
}
}
else
{
throw new Exception("Function has invalid name!");
}
}
public void TupleDefinition()
{
Expression expression = parseExpression("(a, b, 4+6,\"dsas\\\"dasd\", a - g + p * t)");
TupleDefinitionExpression a = assertTypeAndCast <TupleDefinitionExpression>(expression);
Assert.AreEqual(a.members.Count, 5);
VariableReferenceExpression b = assertTypeAndCast <VariableReferenceExpression>(a.members[0]);
VariableReferenceExpression c = assertTypeAndCast <VariableReferenceExpression>(a.members[1]);
AdditionExpression z = assertTypeAndCast <AdditionExpression>(a.members[2]);
StringLiteralExpression d = assertTypeAndCast <StringLiteralExpression>(a.members[3]);
AdditionExpression e = assertTypeAndCast <AdditionExpression>(a.members[4]);
Assert.AreEqual(b.name, "a");
Assert.AreEqual(c.name, "b");
IntegralLiteralExpression y = assertTypeAndCast <IntegralLiteralExpression>(z.left);
IntegralLiteralExpression x = assertTypeAndCast <IntegralLiteralExpression>(z.right);
Assert.AreEqual(4, y.value);
Assert.AreEqual(6, x.value);
Assert.AreEqual(d.value, "dsas\"dasd");
SubtractionExpression f = assertTypeAndCast <SubtractionExpression>(e.left);
MultiplicationExpression g = assertTypeAndCast <MultiplicationExpression>(e.right);
VariableReferenceExpression h = assertTypeAndCast <VariableReferenceExpression>(f.left);
VariableReferenceExpression i = assertTypeAndCast <VariableReferenceExpression>(f.right);
VariableReferenceExpression j = assertTypeAndCast <VariableReferenceExpression>(g.left);
VariableReferenceExpression k = assertTypeAndCast <VariableReferenceExpression>(g.right);
Assert.AreEqual(h.name, "a");
Assert.AreEqual(i.name, "g");
Assert.AreEqual(j.name, "p");
Assert.AreEqual(k.name, "t");
}
public ClassInstantiationExpression(TypeName type, TupleDefinitionExpression arguments)
{
this.type = type;
this.arguments = arguments;
}
public FunctionCallExpression(String name, TupleDefinitionExpression arguments)
{
this.name = name;
this.arguments = arguments;
}
