public ReverseForInStatementSyntax(
IExpressionSyntax itemExpression,
IExpressionSyntax collExpression,
IStatementSyntax statements)
: base(itemExpression, collExpression, statements)
{
}
public ReverseForInStatementSyntax(
VariableDeclarationStatementSyntax variableDeclarationStatement,
IExpressionSyntax collExpression,
IStatementSyntax statements)
: base(variableDeclarationStatement, collExpression, statements)
{
}
private bool TryAdaptStatement(JassMapScriptAdapterContext context, IStatementSyntax statement, [NotNullWhen(true)] out IStatementSyntax?adaptedStatement)
{
return(statement switch
{
JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement => TryAdaptLocalVariableDeclarationStatement(context, localVariableDeclarationStatement, out adaptedStatement),
JassSetStatementSyntax setStatement => TryAdaptSetStatement(context, setStatement, out adaptedStatement),
JassCallStatementSyntax callStatement => TryAdaptCallStatement(context, callStatement, out adaptedStatement),
JassIfStatementSyntax ifStatement => TryAdaptIfStatement(context, ifStatement, out adaptedStatement),
JassLoopStatementSyntax loopStatement => TryAdaptLoopStatement(context, loopStatement, out adaptedStatement),
JassExitStatementSyntax exitStatement => TryAdaptExitStatement(context, exitStatement, out adaptedStatement),
JassReturnStatementSyntax returnStatement => TryAdaptReturnStatement(context, returnStatement, out adaptedStatement),
JassDebugStatementSyntax debugStatement => TryAdaptDebugStatement(context, debugStatement, out adaptedStatement),
_ => TryAdaptDummy(context, statement, out adaptedStatement),
});
public LuaStatementSyntax Transpile(IStatementSyntax statement)
{
return(statement switch
{
JassEmptyStatementSyntax emptyStatement => Transpile(emptyStatement),
JassCommentStatementSyntax commentStatement => Transpile(commentStatement),
JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement => Transpile(localVariableDeclarationStatement),
JassSetStatementSyntax setStatement => Transpile(setStatement),
JassCallStatementSyntax callStatement => Transpile(callStatement),
JassIfStatementSyntax ifStatement => Transpile(ifStatement),
JassLoopStatementSyntax loopStatement => Transpile(loopStatement),
JassExitStatementSyntax exitStatement => Transpile(exitStatement),
JassReturnStatementSyntax returnStatement => Transpile(returnStatement),
JassDebugStatementSyntax debugStatement => Transpile(debugStatement),
});
public ForStatementSyntax(ISyntaxNode parent, JurParser.ForStatementContext context) : base(parent, context)
{
Iterator = context.initializedVariableDeclaration() != null ? new InitializedVariableDeclarationSyntax(this, context.initializedVariableDeclaration())
: context.inferedVariableDeclaration() != null ? new InferredVariableDeclarationSyntax(this, context.inferedVariableDeclaration())
: (IVariableDeclarationSyntax?)null;
Condition = ToExpression(context.expression(0));
Modification = context.expression().Length == 2 ? ToExpression(context.expression(1)) : null;
Body = StatementSyntaxFactory.Create(this, context.statement());
ForLoopType = Iterator != null && Modification != null ? ForLoopType.Classic
: Iterator != null ? ForLoopType.WhileIterator
: Modification != null ? ForLoopType.WhileModify
: ForLoopType.While;
ImmediateChildren = ImmutableArray.Create <ITreeNode>()
.AddIfNotNull(Iterator)
.Add(Condition)
.AddIfNotNull(Modification)
.Add(Body);
}
public void Render(IStatementSyntax statement)
{
switch (statement)
{
case JassCommentStatementSyntax commentStatement: Render(commentStatement); break;
case JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement: Render(localVariableDeclarationStatement); break;
case JassSetStatementSyntax setStatement: Render(setStatement); break;
case JassCallStatementSyntax callStatement: Render(callStatement); break;
case JassIfStatementSyntax ifStatement: Render(ifStatement); break;
case JassLoopStatementSyntax loopStatement: Render(loopStatement); break;
case JassExitStatementSyntax exitStatement: Render(exitStatement); break;
case JassReturnStatementSyntax returnStatement: Render(returnStatement); break;
case JassDebugStatementSyntax debugStatement: Render(debugStatement); break;
}
}
public MainSyntax(ISyntaxNode parent, JurParser.MainContext context) : base(int.MaxValue, parent, context)
{
Body = StatementSyntaxFactory.Create(this, context.statement());
ImmediateChildren = ImmutableArray.Create <ITreeNode>().Add(Body);
}
public GeneratedScopeSyntax(ISyntaxNode parent, JurParser.StatementContext body) : base(parent, body, parent.Line)
{
Body = ToStatement(body);
ImmediateChildren = ImmutableArray.Create <ITreeNode>().AddIfNotNull(Body);
}
private static void RegisterStatement(IStatementSyntax statement, JassMapScriptAdapterContext context)
{
if (statement is JassSetStatementSyntax setStatement)
{
if (!context.KnownLocalVariables.ContainsKey(setStatement.IdentifierName.Name) &&
!context.KnownGlobalVariables.ContainsKey(setStatement.IdentifierName.Name))
{
context.Diagnostics.Add($"Unknown variable '{setStatement.IdentifierName}'.");
}
if (setStatement.Indexer is not null)
{
RegisterExpression(setStatement.Indexer, context);
}
RegisterExpression(setStatement.Value.Expression, context);
}
else if (statement is JassCallStatementSyntax callStatement)
{
if (context.KnownFunctions.TryGetValue(callStatement.IdentifierName.Name, out var knownFunctionParameters))
{
if (knownFunctionParameters.Length != callStatement.Arguments.Arguments.Length)
{
context.Diagnostics.Add($"Invalid function invocation: '{callStatement.IdentifierName}' expected {knownFunctionParameters.Length} parameters but got {callStatement.Arguments.Arguments.Length}.");
}
else
{
for (var i = 0; i < knownFunctionParameters.Length; i++)
{
RegisterExpression(callStatement.Arguments.Arguments[i], context);
}
}
}
else
{
context.Diagnostics.Add($"Unknown function '{callStatement.IdentifierName}'.");
}
}
else if (statement is JassDebugStatementSyntax debugStatement)
{
RegisterStatement(debugStatement, context);
}
else if (statement is JassExitStatementSyntax exitStatement)
{
RegisterExpression(exitStatement.Condition, context);
}
else if (statement is JassIfStatementSyntax ifStatement)
{
RegisterExpression(ifStatement.Condition, context);
RegisterStatementList(ifStatement.Body, context);
foreach (var elseIfClause in ifStatement.ElseIfClauses)
{
RegisterExpression(elseIfClause.Condition, context);
RegisterStatementList(elseIfClause.Body, context);
}
if (ifStatement.ElseClause is not null)
{
RegisterStatementList(ifStatement.ElseClause.Body, context);
}
}
else if (statement is JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement)
{
RegisterVariableDeclarator(localVariableDeclarationStatement.Declarator, false, context);
}
else if (statement is JassLoopStatementSyntax loopStatement)
{
RegisterStatementList(loopStatement.Body, context);
}
else if (statement is JassReturnStatementSyntax returnStatement)
{
if (returnStatement.Value is not null)
{
RegisterExpression(returnStatement.Value, context);
}
}
}
protected BoundStatement(IStatementSyntax syntax)
: base(syntax)
{
}
internal JassDebugStatementSyntax(IStatementSyntax statement)
{
Statement = statement;
}
private BoundStatement BindStatement(IStatementSyntax syntax)
{
return syntax.TypeSwitchExpression<IStatementSyntax, BoundStatement>()
.Case<VariablesDeclarationStatementSyntax>(BindVariablesDeclarationStatement)
.Case<VariableDeclarationStatementSyntax>(BindVariableDeclarationStatement)
.Case<ReturnStatementSyntax>(BindReturnStatement)
.Case<IfElseStatementSyntax>(BindIfElseStatement)
.Case<InvocationStatementSyntax>(BindInvocationStatement)
.Case<IfStatementSyntax>(BindIfStatement)
.Case<AssignmentStatementSyntax>(BindAssignmentStatement)
.Case<ForStatementSyntax>(BindForStatement)
.Case<ForInStatementSyntax>(BindForInStatement)
.Case<ScopeStatementSyntax>(BindScope)
.Case<SwitchStatementSyntax>(BindSwitchStatement)
.Default(() => { throw new NotImplementedException(); })
.Done();
}
