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(); }