public static Argument Evaluate(CompilerState state, SyntaxNode node)
{
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (node is null)
{
throw new ArgumentNullException(nameof(node));
}
var result = node switch
{
TextSyntax text => textInstruction.Evaluate(state, text),
QuoteSyntax quote => quoteInstruction.Evaluate(state, quote),
StringLiteralSyntax stringLiteral => stringInstruction.Evaluate(state, stringLiteral),
ArgumentSyntax argumentSyntax => argumentInstruction.Evaluate(state, argumentSyntax),
CommandSyntax command => commandInstruction.Evaluate(state, command),
ObjectSyntax objectSyntax => objectCreationInstruction.Evaluate(state, objectSyntax),
FieldSyntax fieldSyntax => fieldInstruction.Evaluate(state, fieldSyntax),
ArraySyntax arraySyntax => arrayInstruction.Evaluate(state, arraySyntax),
PercentSyntax percentSyntax => percentInstruction.Evaluate(state, percentSyntax),
ListSyntax list => blockInstruction.Evaluate(state, list),
CommentSyntax _ => null,
_ => throw new ArgumentException($"Evaluation of node type {node.GetType().Name} not implemented.", nameof(node)),
};
return(new Argument(node, result));
}
private static ListSyntax ParseExplicitBlock(ParserContext context)
{
var token = context.Tokens.Dequeue();
var span = token.Span;
var list = new ListSyntax();
SkipWhitespaceTokens(context);
if (context.Tokens.Peek().Type == TokenType.CurlyClose)
{
context.Tokens.Dequeue();
list.Span = span;
return(list);
}
while (token.Type != TokenType.None)
{
if (token.Type == TokenType.CurlyClose)
{
context.Tokens.Dequeue();
break;
}
list.Add(ParseBlock(context));
token = context.Tokens.Peek();
}
list.Span = span.WithEnd(token.Span.End);
return(list);
}
private static void CleanText(ListSyntax list)
{
if (list.Count > 0 && list[^ 1] is TextSyntax textSyntax)
{
textSyntax.Text = textSyntax.Text.TrimEnd();
}
}
public void FailureNullValue()
{
var element = new ListSyntax();
var argument = new Argument(element, null);
var success = DynamicDispatch.IsAssignableFrom(loaded, typeof(string), null, argument, out var transformed);
Assert.False(success);
Assert.Null(transformed);
}
public void SuccessfullArrayString(Type targetType)
{
var element = new ListSyntax();
var value = new string[] { "first", "second" };
var argument = new Argument(element, value);
var success = DynamicDispatch.IsAssignableFrom(loaded, targetType, null, argument, out var transformed);
Assert.True(success);
Assert.IsAssignableFrom(targetType, transformed);
}
public void SuccessfullSingleString(Type targetType)
{
var element = new ListSyntax();
var value = "stringValue";
var argument = new Argument(element, value);
var success = DynamicDispatch.IsAssignableFrom(loaded, targetType, null, argument, out var transformed);
Assert.True(success);
Assert.IsAssignableFrom(targetType, transformed);
}
private static ListSyntax <ArgumentSyntax> ParseArguments(ParserContext context)
{
var token = context.Tokens.Dequeue();
var span = token.Span;
var list = new ListSyntax <ArgumentSyntax>();
SkipWhitespaceTokens(context);
if (context.Tokens.Peek().Type == TokenType.ParenthesesClose)
{
context.Tokens.Dequeue();
list.Span = span;
return(list);
}
while (token.Type != TokenType.None)
{
if (token.Type == TokenType.ParenthesesClose)
{
context.Tokens.Dequeue();
break;
}
else if (token.Type == TokenType.Semicolon)
{
context.Tokens.Dequeue();
}
list.Add(ParseArgument(context));
token = context.Tokens.Peek();
}
for (int i = 0; i < list.Count; i++)
{
list[i].Position = i;
}
list.Span = span.WithEnd(token.Span.End);
return(list);
}
private static ObjectSyntax ParseObject(ParserContext context)
{
var token = context.Tokens.Dequeue();
var span = token.Span;
var obj = new ObjectSyntax();
var list = new ListSyntax <FieldSyntax>();
obj.Fields = list;
SkipWhitespaceTokens(context);
if (context.Tokens.Peek().Type == TokenType.CurlyClose)
{
context.Tokens.Dequeue();
list.Span = span;
return(obj);
}
while (token.Type != TokenType.None)
{
if (token.Type == TokenType.CurlyClose)
{
context.Tokens.Dequeue();
break;
}
var field = ParseField(context);
if (field != null)
{
list.Add(field);
}
token = context.Tokens.Peek();
}
list.Span = span.WithEnd(token.Span.End);
return(obj);
}
private static ListSyntax ParseBlock(ParserContext context, params TokenType[] stop)
{
var token = context.Tokens.Peek();
var span = token !.Span;
var list = new ListSyntax();
bool continueParsing = true;
SyntaxNode?outNode = null;
while (continueParsing && token.Type != TokenType.None)
{
continueParsing = ParseElement(context, stop, out outNode);
if (outNode != null)
{
list.Add(outNode);
}
token = context.Tokens.Peek();
}
token = context.Tokens.Peek();
list.Span = span.WithEnd(token.Span.End);
context.Tokens.SkipWhile(e => e.Type == TokenType.Newline);
return(list);
}
