private BoundIfStatement BindIfStatement(IfStatementSyntax syntax) { BaseBoundExpression ifExpression = this.BindExpression(syntax.IfPart.Condition); BoundStatementBlock ifBody = this.BindStatementBlock(syntax.IfPart.Body); BoundIfPart ifPart = new BoundIfPart(syntax.IfPart, ifExpression, ifBody); List <BoundElseIfPart> elseIfParts = new List <BoundElseIfPart>(); foreach (var part in syntax.ElseIfParts) { BaseBoundExpression elseIfExpression = this.BindExpression(part.Condition); BoundStatementBlock elseIfBody = this.BindStatementBlock(part.Body); elseIfParts.Add(new BoundElseIfPart(part, elseIfExpression, elseIfBody)); } BoundElsePart elsePart = null; if (!syntax.ElsePartOpt.IsDefault()) { BoundStatementBlock elseBody = this.BindStatementBlock(syntax.ElsePartOpt.Body); elsePart = new BoundElsePart(syntax.ElsePartOpt, elseBody); } return(new BoundIfStatement(syntax, ifPart, elseIfParts, elsePart)); }
private BoundBinaryExpression BindBinaryOperatorExpression(BinaryOperatorExpressionSyntax syntax) { BaseBoundExpression left = this.BindExpression(syntax.Left); BaseBoundExpression right = this.BindExpression(syntax.Right, expectsValue: !(left is BoundLibraryEventExpression)); switch (syntax.OperatorToken.Kind) { case TokenKind.Or: case TokenKind.And: case TokenKind.NotEqual: case TokenKind.Equal: case TokenKind.LessThan: case TokenKind.GreaterThan: case TokenKind.LessThanOrEqual: case TokenKind.GreaterThanOrEqual: case TokenKind.Plus: case TokenKind.Minus: case TokenKind.Multiply: case TokenKind.Divide: return(new BoundBinaryExpression(syntax, hasValue: true, left.HasErrors || right.HasErrors, syntax.OperatorToken.Kind, left, right)); default: throw ExceptionUtilities.UnexpectedValue(syntax.OperatorToken.Kind); } }
private BoundWhileStatement BindWhileStatement(WhileStatementSyntax syntax) { BaseBoundExpression expression = this.BindExpression(syntax.Condition); BoundStatementBlock body = this.BindStatementBlock(syntax.Body); return(new BoundWhileStatement(syntax, expression, body)); }
public BoundInvalidExpressionStatement(ExpressionStatementSyntax syntax, BaseBoundExpression expression) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Expression = expression; }
public BoundWhileStatement(WhileStatementSyntax syntax, BaseBoundExpression condition, BoundStatementBlock body) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!condition.IsDefault(), "'condition' must not be null."); Debug.Assert(!body.IsDefault(), "'body' must not be null."); this.Syntax = syntax; this.Condition = condition; this.Body = body; }
private BoundUnaryExpression BindUnaryOperatorExpression(UnaryOperatorExpressionSyntax syntax) { BaseBoundExpression expression = this.BindExpression(syntax.Expression); switch (syntax.OperatorToken.Kind) { case TokenKind.Minus: return(new BoundUnaryExpression(syntax, hasValue: true, expression.HasErrors, syntax.OperatorToken.Kind, expression)); default: throw ExceptionUtilities.UnexpectedValue(syntax.OperatorToken.Kind); } }
public BoundForStatement(ForStatementSyntax syntax, string identifier, BaseBoundExpression fromExpression, BaseBoundExpression toExpression, BaseBoundExpression stepExpressionOpt, BoundStatementBlock body) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!identifier.IsDefault(), "'identifier' must not be null."); Debug.Assert(!fromExpression.IsDefault(), "'fromExpression' must not be null."); Debug.Assert(!toExpression.IsDefault(), "'toExpression' must not be null."); Debug.Assert(!body.IsDefault(), "'body' must not be null."); this.Syntax = syntax; this.Identifier = identifier; this.FromExpression = fromExpression; this.ToExpression = toExpression; this.StepExpressionOpt = stepExpressionOpt; this.Body = body; }
private BoundForStatement BindForStatement(ForStatementSyntax syntax) { string identifier = syntax.IdentifierToken.Text; BaseBoundExpression fromExpression = this.BindExpression(syntax.FromExpression); BaseBoundExpression toExpression = this.BindExpression(syntax.ToExpression); BaseBoundExpression stepExpression = null; if (!syntax.StepClauseOpt.IsDefault()) { stepExpression = this.BindExpression(syntax.StepClauseOpt.Expression); } BoundStatementBlock body = this.BindStatementBlock(syntax.Body); return(new BoundForStatement(syntax, identifier, fromExpression, toExpression, stepExpression, body)); }
private BaseBoundExpression BindArrayAccessExpression(ArrayAccessExpressionSyntax syntax) { BaseBoundExpression baseExpression = this.BindExpression(syntax.BaseExpression); BaseBoundExpression indexExpression = this.BindExpression(syntax.IndexExpression); string arrayName; List <BaseBoundExpression> indices = new List <BaseBoundExpression>(); bool hasErrors = baseExpression.HasErrors || indexExpression.HasErrors; switch (baseExpression) { case BoundArrayAccessExpression arrayAccess: { arrayName = arrayAccess.Name; indices.AddRange(arrayAccess.Indices); indices.Add(indexExpression); break; } case BoundVariableExpression variable: { arrayName = variable.Name; indices.Add(indexExpression); break; } default: { if (!hasErrors) { hasErrors = true; this.diagnostics.ReportUnsupportedArrayBaseExpression(syntax.BaseExpression.Range); } return(new BoundInvalidExpression(syntax, hasValue: true, hasErrors)); } } return(new BoundArrayAccessExpression(syntax, hasValue: true, hasErrors, arrayName, indices)); }
private BaseBoundStatement BindExpressionStatement(ExpressionStatementSyntax syntax) { BaseBoundExpression expression = this.BindExpression(syntax.Expression, expectsValue: false); if (expression.HasErrors) { return(new BoundInvalidExpressionStatement(syntax, expression)); } switch (expression) { case BoundBinaryExpression assignment when assignment.Kind == TokenKind.Equal: { return(this.BindAssignmentExpressionStatement(syntax, assignment)); } case BoundLibraryMethodInvocationExpression methodInvocation: { return(new BoundLibraryMethodInvocationStatement(syntax, methodInvocation)); } case BoundSubModuleInvocationExpression subModuleInvocation: { return(new BoundSubModuleInvocationStatement(syntax, subModuleInvocation)); } } if (expression.HasValue) { this.diagnostics.ReportUnassignedExpressionStatement(syntax.Range); } else { this.diagnostics.ReportInvalidExpressionStatement(syntax.Range); } return(new BoundInvalidExpressionStatement(syntax, expression)); }
private BaseBoundExpression BindObjectAccessExpression(ObjectAccessExpressionSyntax syntax, bool expectsValue) { BaseBoundExpression baseExpression = this.BindExpression(syntax.BaseExpression, expectsValue: false); string identifier = syntax.IdentifierToken.Text; bool hasErrors = baseExpression.HasErrors; if (baseExpression is BoundLibraryTypeExpression libraryTypeExpression) { Library library = Libraries.Types[libraryTypeExpression.Name]; if (library.Properties.TryGetValue(identifier, out Property property)) { bool noGetter = property.Getter.IsDefault(); if (!hasErrors) { if (expectsValue && noGetter) { hasErrors = true; this.diagnostics.ReportExpectedExpressionWithAValue(syntax.Range); } else if (property.IsDeprecated) { hasErrors = true; this.diagnostics.ReportLibraryMemberDeprecatedFromOlderVersion(syntax.Range, library.Name, property.Name); } else if (property.NeedsDesktop && !this.isRunningOnDesktop) { hasErrors = true; this.diagnostics.ReportLibraryMemberNeedsDesktop(syntax.Range, library.Name, property.Name); } } return(new BoundLibraryPropertyExpression(syntax, hasValue: !noGetter, hasErrors, libraryTypeExpression, identifier)); } if (library.Methods.TryGetValue(identifier, out Method method)) { if (!hasErrors) { if (expectsValue) { hasErrors = true; this.diagnostics.ReportExpectedExpressionWithAValue(syntax.Range); } else if (method.IsDeprecated) { hasErrors = true; this.diagnostics.ReportLibraryMemberDeprecatedFromOlderVersion(syntax.Range, library.Name, method.Name); } else if (method.NeedsDesktop && !this.isRunningOnDesktop) { hasErrors = true; this.diagnostics.ReportLibraryMemberNeedsDesktop(syntax.Range, library.Name, method.Name); } } return(new BoundLibraryMethodExpression(syntax, hasValue: false, hasErrors, libraryTypeExpression, identifier)); } if (library.Events.ContainsKey(identifier)) { return(new BoundLibraryEventExpression(syntax, hasValue: false, hasErrors, libraryTypeExpression, identifier)); } this.diagnostics.ReportLibraryMemberNotFound(syntax.Range, library.Name, identifier); return(new BoundInvalidExpression(syntax, hasValue: true, hasErrors: true)); } else { this.diagnostics.ReportUnsupportedDotBaseExpression(syntax.BaseExpression.Range); return(new BoundInvalidExpression(syntax, hasValue: true, hasErrors: true)); } }
public BoundUnaryExpression(UnaryOperatorExpressionSyntax syntax, bool hasValue, bool hasErrors, TokenKind kind, BaseBoundExpression expression) : base(hasValue, hasErrors) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!kind.IsDefault(), "'kind' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Kind = kind; this.Expression = expression; }
public BoundArrayAssignmentStatement(ExpressionStatementSyntax syntax, BoundArrayAccessExpression array, BaseBoundExpression expression) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!array.IsDefault(), "'array' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Array = array; this.Expression = expression; }
public BoundPropertyAssignmentStatement(ExpressionStatementSyntax syntax, BoundLibraryPropertyExpression property, BaseBoundExpression expression) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!property.IsDefault(), "'property' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Property = property; this.Expression = expression; }
public BoundVariableAssignmentStatement(ExpressionStatementSyntax syntax, BoundVariableExpression variable, BaseBoundExpression expression) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!variable.IsDefault(), "'variable' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Variable = variable; this.Expression = expression; }
private BoundParenthesisExpression BindParenthesisExpression(ParenthesisExpressionSyntax syntax) { BaseBoundExpression expression = this.BindExpression(syntax.Expression); return(new BoundParenthesisExpression(syntax, hasValue: true, expression.HasErrors, expression)); }
public BoundBinaryExpression(BinaryOperatorExpressionSyntax syntax, bool hasValue, bool hasErrors, TokenKind kind, BaseBoundExpression left, BaseBoundExpression right) : base(hasValue, hasErrors) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!kind.IsDefault(), "'kind' must not be null."); Debug.Assert(!left.IsDefault(), "'left' must not be null."); Debug.Assert(!right.IsDefault(), "'right' must not be null."); this.Syntax = syntax; this.Kind = kind; this.Left = left; this.Right = right; }
private BaseBoundExpression BindInvocationExpression(InvocationExpressionSyntax syntax, bool expectsValue) { BaseBoundExpression baseExpression = this.BindExpression(syntax.BaseExpression, expectsValue: false); bool hasErrors = baseExpression.HasErrors; List <BaseBoundExpression> arguments = new List <BaseBoundExpression>(); foreach (ArgumentSyntax arg in syntax.Arguments) { BaseBoundExpression argument = this.BindExpression(arg.Expression); hasErrors |= argument.HasErrors; arguments.Add(argument); } switch (baseExpression) { case BoundLibraryMethodExpression libraryMethod: { Method method = Libraries.Types[libraryMethod.Library.Name].Methods[libraryMethod.Name]; if (!hasErrors) { if (arguments.Count != method.Parameters.Count) { hasErrors = true; this.diagnostics.ReportUnexpectedArgumentsCount(syntax.Range, arguments.Count, method.Parameters.Count); } else if (expectsValue && !method.ReturnsValue) { hasErrors = true; this.diagnostics.ReportExpectedExpressionWithAValue(syntax.Range); } } return(new BoundLibraryMethodInvocationExpression(syntax, method.ReturnsValue, hasErrors, libraryMethod, arguments)); } case BoundSubModuleExpression subModule: { if (!hasErrors) { if (arguments.Count != 0) { hasErrors = true; this.diagnostics.ReportUnexpectedArgumentsCount(syntax.Range, arguments.Count, 0); } else if (expectsValue) { hasErrors = true; this.diagnostics.ReportExpectedExpressionWithAValue(syntax.Range); } } return(new BoundSubModuleInvocationExpression(syntax, hasValue: false, hasErrors, subModule.Name)); } default: { this.diagnostics.ReportUnsupportedInvocationBaseExpression(syntax.Range); return(new BoundInvalidExpression(syntax, hasValue: true, hasErrors: true)); } } }
public BoundParenthesisExpression(ParenthesisExpressionSyntax syntax, bool hasValue, bool hasErrors, BaseBoundExpression expression) : base(hasValue, hasErrors) { Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null."); Debug.Assert(!expression.IsDefault(), "'expression' must not be null."); this.Syntax = syntax; this.Expression = expression; }