public void GetArgumentSyntax_WhenCreatingWithBinaryExpression_ShouldGetCorrectCode()
{
var argument = new LambdaArgument(new ConditionalBinaryExpression(new MemberReference("n"), new MemberReference("true"), ConditionalStatements.Equal).GetBinaryExpression(), "n");
var syntax = argument.GetArgumentSyntax();
Assert.IsInstanceOf <ArgumentSyntax>(syntax);
Assert.AreEqual("n=>n==true", syntax.ToString());
}
public void GetArgumentSyntax_WhenCreatingEmptyAsNamedArgument_ShouldGetCorrectCode()
{
var argument = new LambdaArgument(Statement.Expression.Invoke("MyMethod").AsExpression(), "n", namedArgument: "namedArgument");
var syntax = argument.GetArgumentSyntax();
Assert.IsInstanceOf <ArgumentSyntax>(syntax);
Assert.AreEqual("namedArgument:n=>MyMethod()", syntax.ToString());
}
public void GetArgumentSyntax_WhenCreatingWithWithBlock_ShouldGetCorrectCode()
{
var block = BodyGenerator.Create(Statement.Expression.Invoke("MyMethod").AsStatement());
var argument = new LambdaArgument(block, "n");
var syntax = argument.GetArgumentSyntax();
Assert.IsInstanceOf <ArgumentSyntax>(syntax);
Assert.AreEqual("n=>{MyMethod();}", syntax.ToString());
}
public bool ParseLambdaSignature(ref StructList <LambdaArgument> signature)
{
tokenStream.Save();
while (tokenStream.HasMoreTokens)
{
// can be either just names or type specifier and then names. can probably also be aliases
TypeLookup typeLookup = default;
LambdaArgument argument = default;
// should parse a path even if only an identifier is present
if (ParseTypePath(ref typeLookup))
{
argument.type = typeLookup;
}
else
{
tokenStream.Restore();
return(false);
}
if (!tokenStream.HasMoreTokens)
{
if (typeLookup.generics != null || !string.IsNullOrEmpty(typeLookup.namespaceName))
{
tokenStream.Restore();
return(false);
}
argument.identifier = typeLookup.typeName;
argument.type = null;
signature.Add(argument);
return(true);
}
if (tokenStream.Current == ExpressionTokenType.Identifier)
{
argument.identifier = tokenStream.Current;
tokenStream.Advance();
signature.Add(argument);
}
else if (tokenStream.Current == ExpressionTokenType.Comma)
{
argument.identifier = typeLookup.typeName;
argument.type = null;
signature.Add(argument);
}
if (!tokenStream.HasMoreTokens)
{
return(true);
}
// better be a comma or end if have more tokens
if (tokenStream.Current != ExpressionTokenType.Comma)
{
signature.Clear();
Abort($"Failed parse LambdaExpression signature because we expected a comma and we hit {tokenStream.Current} instead.");
return(false);
}
tokenStream.Advance();
}
return(true);
}
