public ImplicitImmutabilityConversionExpression(
IExpressionSyntax expression,
ObjectType convertToType)
: base(expression.Span, convertToType, expression, expression.Semantics.Assigned())
{
ConvertToType = convertToType;
}
public InitializerSyntax(ISyntaxNode parent, string fieldName, JurParser.ExpressionContext context) : base(parent, context)
{
FieldName = fieldName;
Expression = ToExpression(context);
ImmediateChildren = ImmutableArray.Create <ITreeNode>()
.Add(Expression);
}
public JassIfStatementSyntax(IExpressionSyntax condition, JassStatementListSyntax body, params JassElseIfStatementSyntax[] elseIfStatements)
{
Condition = condition;
Body = body;
ElseIfStatements = elseIfStatements.ToImmutableArray();
ElseClause = null;
}
public ImplicitNumericConversionExpression(
IExpressionSyntax expression,
NumericType convertToType)
: base(expression.Span, convertToType, expression, ExpressionSemantics.Copy)
{
ConvertToType = convertToType;
}
public ReverseForInStatementSyntax(
VariableDeclarationStatementSyntax variableDeclarationStatement,
IExpressionSyntax collExpression,
IStatementSyntax statements)
: base(variableDeclarationStatement, collExpression, statements)
{
}
public JassIfStatementSyntax(IExpressionSyntax condition, JassStatementListSyntax body, ImmutableArray <JassElseIfStatementSyntax> elseIfStatements, JassElseClauseSyntax?elseClause)
{
Condition = condition;
Body = body;
ElseIfStatements = elseIfStatements;
ElseClause = elseClause;
}
public ReverseForInStatementSyntax(
IExpressionSyntax itemExpression,
IExpressionSyntax collExpression,
IStatementSyntax statements)
: base(itemExpression, collExpression, statements)
{
}
public JassIfStatementSyntax(IExpressionSyntax condition, JassStatementListSyntax body)
{
Condition = condition;
Body = body;
ElseIfStatements = ImmutableArray.Create <JassElseIfStatementSyntax>();
ElseClause = null;
}
public static JassSetStatementSyntax SetStatement(string name, IExpressionSyntax indexer, JassEqualsValueClauseSyntax value)
{
return(new JassSetStatementSyntax(
ParseIdentifierName(name),
indexer,
value));
}
public ResultStatementSyntax(
TextSpan span,
IExpressionSyntax expression)
: base(span)
{
this.expression = expression;
}
public AssignmentStatementSyntax(ISyntaxNode parent, JurParser.AssignmentStatementContext context) : base(parent, context)
{
Left = ToExpression(context.expression(0));
Right = ToExpression(context.expression(1));
ImmediateChildren = ImmutableArray.Create <ITreeNode>().Add(Left).Add(Right);
}
public NegationExpressionSyntax(ISyntaxNode parent, JurParser.NegationContext context) : base(parent, context)
{
Expression = ToExpression(context.expression());
ImmediateChildren = ImmutableArray.Create <ITreeNode>()
.Add(Expression);
}
public static JassIfStatementSyntax IfStatement(IExpressionSyntax condition, JassStatementListSyntax body, IEnumerable <JassElseIfClauseSyntax> elseIfClauses, JassElseClauseSyntax elseClause)
{
return(new JassIfStatementSyntax(
condition,
body,
elseIfClauses.ToImmutableArray(),
elseClause));
}
public static JassIfStatementSyntax IfStatement(IExpressionSyntax condition, JassStatementListSyntax body, params JassElseIfClauseSyntax[] elseIfClauses)
{
return(new JassIfStatementSyntax(
condition,
body,
elseIfClauses.ToImmutableArray(),
null));
}
public static JassIfStatementSyntax IfStatement(IExpressionSyntax condition, JassStatementListSyntax body, JassElseClauseSyntax elseClause)
{
return(new JassIfStatementSyntax(
condition,
body,
ImmutableArray.Create <JassElseIfClauseSyntax>(),
elseClause));
}
public static JassIfStatementSyntax IfStatement(IExpressionSyntax condition, params IStatementSyntax[] body)
{
return(new JassIfStatementSyntax(
condition,
StatementList(body),
ImmutableArray.Create <JassElseIfClauseSyntax>(),
null));
}
public ImplicitNoneConversionExpression(
IExpressionSyntax expression,
OptionalType convertToType)
// We can always copy the `none` literal
: base(expression.Span, convertToType, expression, ExpressionSemantics.Copy)
{
ConvertToType = convertToType;
}
public IfElseStatementSyntax(
IExpressionSyntax condition,
ScopeStatementSyntax statements,
ScopeStatementSyntax elseStatements)
: base(condition, statements)
{
ElseStatements = elseStatements;
}
public ExpressionBinOpSyntax(Token op,
IExpressionSyntax leftExpressionSyntax,
IExpressionSyntax rightExpressionSyntax)
{
this.op = op;
this.leftExpressionSyntax = leftExpressionSyntax;
this.rightExpressionSyntax = rightExpressionSyntax;
}
public OperationSyntax(ISyntaxNode parent, JurParser.OperationContext context) : base(parent, context)
{
var op = context.@operator?.Text ?? context.LOGICAL_AND()?.GetText() ?? context.OR()?.GetText();
Operator = op !;
Left = ToExpression(context.expression(0));
Right = ToExpression(context.expression(1));
ImmediateChildren = ImmutableArray.Create <ITreeNode>().Add(Left).Add(Right);
}
public WhileExpressionSyntax(
TextSpan span,
IExpressionSyntax condition,
IBlockExpressionSyntax block)
: base(span)
{
this.condition = condition;
Block = block;
}
public AssignmentExpressionSyntax(
IAssignableExpressionSyntax leftOperand,
AssignmentOperator @operator,
IExpressionSyntax rightOperand)
: base(TextSpan.Covering(leftOperand.Span, rightOperand.Span))
{
this.leftOperand = leftOperand;
this.rightOperand = rightOperand;
Operator = @operator;
}
public BoundInvocationExpression(
BoundExpression toInvoke,
List<BoundExpression> boundParameter,
IExpressionSyntax expressionSyntax,
IType type)
: base(expressionSyntax, type)
{
ToInvoke = toInvoke;
BoundParameter = boundParameter;
}
public BinaryOperatorExpressionSyntax(
IExpressionSyntax leftOperand,
BinaryOperator @operator,
IExpressionSyntax rightOperand)
: base(TextSpan.Covering(leftOperand.Span, rightOperand.Span))
{
this.leftOperand = leftOperand;
Operator = @operator;
this.rightOperand = rightOperand;
}
public UnaryOperatorExpressionSyntax(
TextSpan span,
UnaryOperatorFixity fixity,
UnaryOperator @operator,
IExpressionSyntax operand)
: base(span, ExpressionSemantics.Copy)
{
Operator = @operator;
this.operand = operand;
Fixity = fixity;
}
public QualifiedNameExpressionSyntax(
TextSpan span,
IExpressionSyntax context,
AccessOperator accessOperator,
INameExpressionSyntax field)
: base(span)
{
this.context = context;
AccessOperator = accessOperator;
Field = field;
}
public IfExpressionSyntax(
TextSpan span,
IExpressionSyntax condition,
IBlockOrResultSyntax thenBlock,
IElseClauseSyntax?elseClause)
: base(span)
{
this.condition = condition;
ThenBlock = thenBlock;
ElseClause = elseClause;
}
private DeclarationStatementSyntax ParseDeclarationStatement(bool isVar)
{
Expect(TokenType.Identifier);
var identifierToken = Current();
IExpressionSyntax initializer = null;
if (Accept(TokenType.Equals))
{
initializer = ParseExpression();
}
ExpectIfNotEnded(TokenType.NewLine);
return(new DeclarationStatementSyntax(isVar, identifierToken, initializer));
}
private VarOrCallChainMaybeAssignStatementSyntax ParseVarOrCallChainMaybeAssignStatement()
{
var varOrCallChain = ParseVarOrCallChain();
//TODO Handle assign
IExpressionSyntax valueToAssignExpression = null;
if (Accept(TokenType.Equals))
{
valueToAssignExpression = ParseExpression();
}
ExpectIfNotEnded(TokenType.NewLine);
return(new VarOrCallChainMaybeAssignStatementSyntax(varOrCallChain, valueToAssignExpression));
}
public ForeachExpressionSyntax(
TextSpan span,
bool isMutableBinding,
Name variableName,
ITypeSyntax?typeSyntax,
IExpressionSyntax inExpression,
IBlockExpressionSyntax block)
: base(span)
{
IsMutableBinding = isMutableBinding;
VariableName = variableName;
this.inExpression = inExpression;
Block = block;
Type = typeSyntax;
}
private IExpression CompileExpression(IExpressionSyntax expressionSyntax,
int parentOpPrecedence = int.MaxValue)
{
if (expressionSyntax.GetType() == typeof(ExpressionBinOpSyntax))
{
var expressionBinOpSyntax = (ExpressionBinOpSyntax)expressionSyntax;
var left = CompileExpression(expressionBinOpSyntax.leftExpressionSyntax);
var right = CompileExpression(expressionBinOpSyntax.rightExpressionSyntax);
Type type;
switch (expressionBinOpSyntax.op.value)
{
case "<":
case ">":
type = typeResolver.boolType;
break;
default:
// TODO handle type conversions
type = left.Type;
break;
}
return(new ExpressionBinOp(expressionBinOpSyntax.op,
left,
right,
type));
}
else if (expressionSyntax.GetType() == typeof(ExpressionParenthesizedSyntax))
{
var expressionParenthesizedSyntax = (ExpressionParenthesizedSyntax)expressionSyntax;
return(new ExpressionParenthesized(CompileExpression(expressionParenthesizedSyntax.expression)));
}
else if (expressionSyntax.GetType() == typeof(ExpressionLiteralSyntax))
{
var expressionLiteralSyntax = (ExpressionLiteralSyntax)expressionSyntax;
return(CompileExpressionLiteral(expressionLiteralSyntax));
}
else if (expressionSyntax.GetType() == typeof(VarOrCallChainSyntax))
{
var varOrCallChainSyntax = (VarOrCallChainSyntax)expressionSyntax;
return(CompileVarOrCallChain(varOrCallChainSyntax));
}
else
{
throw new CompilerException($"Could not determine type of expression");
}
}
public static void AreEqual(IExpressionSyntax expected, IExpressionSyntax actual)
{
var expectedString = expected.ToString();
var actualString = actual.ToString();
var expectedType = expected.GetType().Name;
var actualType = actual.GetType().Name;
var isStringCorrect = string.Equals(expectedString, actualString, StringComparison.Ordinal);
var isTypeCorrect = string.Equals(expectedType, actualType, StringComparison.Ordinal);
var message = isStringCorrect == isTypeCorrect
? $"\r\nExpected: '{expectedString}'<{expected.GetType().Name}>.\r\n Actual: '{actualString}'<{actual.GetType().Name}>"
: isStringCorrect
? $"\r\nExpected: <{expectedType}>.\r\n Actual: <{actualType}>."
: $"\r\nExpected: '{expectedString}'.\r\n Actual: '{actualString}'.";
Assert.IsTrue(expected.Equals(actual), message);
}
public ExpressionSyntax Transpile(IExpressionSyntax expression)
{
return(expression switch
{
JassCharacterLiteralExpressionSyntax characterLiteralExpression => Transpile(characterLiteralExpression),
JassFourCCLiteralExpressionSyntax fourCCLiteralExpression => Transpile(fourCCLiteralExpression),
JassHexadecimalLiteralExpressionSyntax hexadecimalLiteralExpression => Transpile(hexadecimalLiteralExpression),
JassRealLiteralExpressionSyntax realLiteralExpression => Transpile(realLiteralExpression),
JassOctalLiteralExpressionSyntax octalLiteralExpression => Transpile(octalLiteralExpression),
JassDecimalLiteralExpressionSyntax decimalLiteralExpression => Transpile(decimalLiteralExpression),
JassBooleanLiteralExpressionSyntax booleanLiteralExpression => Transpile(booleanLiteralExpression),
JassStringLiteralExpressionSyntax stringLiteralExpression => Transpile(stringLiteralExpression),
JassNullLiteralExpressionSyntax nullLiteralExpression => Transpile(nullLiteralExpression),
JassFunctionReferenceExpressionSyntax functionReferenceExpression => Transpile(functionReferenceExpression),
JassInvocationExpressionSyntax invocationExpression => Transpile(invocationExpression),
JassArrayReferenceExpressionSyntax arrayReferenceExpression => Transpile(arrayReferenceExpression),
JassVariableReferenceExpressionSyntax variableReferenceExpression => Transpile(variableReferenceExpression),
JassParenthesizedExpressionSyntax parenthesizedExpression => Transpile(parenthesizedExpression),
JassUnaryExpressionSyntax unaryExpression => Transpile(unaryExpression),
JassBinaryExpressionSyntax binaryExpression => Transpile(binaryExpression),
});
private bool TryAdaptBlzCreateInvocation <TInvocation>(
JassMapScriptAdapterContext context,
TInvocation invocation,
[NotNullWhen(true)] out string?adaptedInvocationName,
[NotNullWhen(true)] out JassArgumentListSyntax?adaptedInvocationArguments,
string replacementFunctionName,
int expectedArgumentCount,
int typeIdArgumentIndex,
int skinIdArgumentIndex)
where TInvocation : IInvocationSyntax
{
if (invocation.Arguments.Arguments.Length == expectedArgumentCount &&
invocation.Arguments.Arguments[typeIdArgumentIndex].TryGetIntegerExpressionValue(out var typeId) &&
invocation.Arguments.Arguments[skinIdArgumentIndex].TryGetIntegerExpressionValue(out var skinId))
{
if (typeId == skinId)
{
var arguments = new IExpressionSyntax[expectedArgumentCount - 1];
for (var i = 0; i < expectedArgumentCount; i++)
{
if (i == skinIdArgumentIndex)
{
continue;
}
arguments[i > skinIdArgumentIndex ? i - 1 : i] = invocation.Arguments.Arguments[i];
}
adaptedInvocationName = replacementFunctionName;
adaptedInvocationArguments = JassSyntaxFactory.ArgumentList(arguments);
return(true);
}
else
{
context.Diagnostics.Add($"Unable to adapt '{invocation.IdentifierName}' to '{replacementFunctionName}', because the skin '{skinId.ToRawcode()}' is not the same as the type '{typeId.ToRawcode()}'.");
}
}
public void Add(IExpressionSyntax expression)
{
_flatList.Add(expression);
}
private BoundExpression BindExpression(IExpressionSyntax syntax, List<IType> args = null)
{
return syntax.TypeSwitchExpression<IExpressionSyntax, BoundExpression>()
.Case<AnonymousFunctionExpressionSyntax>(BindAnonymousFunctionExpression)
.Case<BooleanExpressionSyntax>(BindBooleanExpression)
.Case<IntExpressionSyntax>(BindIntExpression)
.Case<FloatExpressionSyntax>(BindFloatExpression)
.Case<StringExpressionSyntax>(BindStringExpression)
.Case<InvocationExpressionSyntax>(BindInvocationExpression)
.Case<InfixFunctionInvocationExpressionSyntax>(BindInfixFunctionInvocationExpression)
.Case<IdentifierExpressionSyntax>(x => BindMemberExpression(x, args))
.Case<ArrayCreationExpressionSyntax>(BindArrayCreationExpression)
.Case<ObjectCreationExpressionSyntax>(BindObjectCreationExpression)
.Case<MemberAccessExpressionSyntax>(x => BindMemberAccessExpression(x, args))
.Case<ArrayAccessExpressionSyntax>(BindArrayAccessExpression)
.Case<BinaryExpressionSyntax>(BindBinaryExpression)
.Case<IfElseExpressionSyntax>(BindIfElseExpression)
.Default(() => { throw new NotImplementedException(); })
.Done();
}
