private StatementSyntax GetFinalStatement( ExpressionSyntax switchExpression, SyntaxTriviaList leadingTrivia, ITypeSymbol declaratorToRemoveTypeOpt, SyntaxKind nodeToGenerate, bool generateDeclaration) { switch (nodeToGenerate) { case SyntaxKind.ReturnStatement: return(ReturnStatement( Token(leadingTrivia, SyntaxKind.ReturnKeyword, trailing: default), switchExpression, Token(SyntaxKind.SemicolonToken))); case SyntaxKind.ThrowStatement: return(ThrowStatement( Token(leadingTrivia, SyntaxKind.ThrowKeyword, trailing: default), switchExpression, Token(SyntaxKind.SemicolonToken))); } Debug.Assert(SyntaxFacts.IsAssignmentExpression(nodeToGenerate)); Debug.Assert(_assignmentTargetOpt != null); return(generateDeclaration ? GenerateVariableDeclaration(switchExpression, leadingTrivia, declaratorToRemoveTypeOpt) : GenerateAssignment(switchExpression, nodeToGenerate, leadingTrivia)); }
private static ExpressionSyntax ConvertInvocation(InvocationExpressionSyntax invocation) { var arguments = invocation.ArgumentList.Arguments; if (arguments.Count == 1) { // Assignment expressions in a collection initializer will cause the compiler to // report an error. This is because { a = b } is the form for an object initializer, // and the two forms are not allowed to mix/match. Parenthesize the assignment to // avoid the ambiguity. var expression = arguments[0].Expression; return(SyntaxFacts.IsAssignmentExpression(expression.Kind()) ? SyntaxFactory.ParenthesizedExpression(expression) : expression); } return(SyntaxFactory.InitializerExpression( SyntaxKind.ComplexElementInitializerExpression, SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithoutTrivia(), SyntaxFactory.SeparatedList( arguments.Select(a => a.Expression), arguments.GetSeparators() ), SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithoutTrivia() )); }
internal static bool CanBeInitializerExpressionInForStatement(SyntaxKind kind) { switch (kind) { case SyntaxKind.InvocationExpression: case SyntaxKind.PreIncrementExpression: case SyntaxKind.PreDecrementExpression: case SyntaxKind.PostIncrementExpression: case SyntaxKind.PostDecrementExpression: case SyntaxKind.ObjectCreationExpression: case SyntaxKind.AwaitExpression: return(true); } return(SyntaxFacts.IsAssignmentExpression(kind)); }
public override string VisitBinaryExpression(BinaryExpressionSyntax node) { string token = node.OperatorToken.ToFullString().Trim(); if (token == "%") { throw new ShaderGenerationException( "Modulus operator not supported in shader functions. Use ShaderBuiltins.Mod instead."); } string leftExpr = Visit(node.Left); string leftExprType = Utilities.GetFullTypeName(GetModel(node), node.Left); string operatorToken = node.OperatorToken.ToString(); string rightExpr = Visit(node.Right); string rightExprType = Utilities.GetFullTypeName(GetModel(node), node.Right); if (SyntaxFacts.IsAssignmentExpression(node.Kind())) { MarkWritten(node.Left); } return(_backend.CorrectBinaryExpression(leftExpr, leftExprType, operatorToken, rightExpr, rightExprType)); }
private bool IsPossibleExpression() { var tk = Current.Kind; switch (tk) { case SyntaxKind.FalseKeyword: case SyntaxKind.TrueKeyword: case SyntaxKind.OpenParenToken: case SyntaxKind.IntegerLiteralToken: case SyntaxKind.FloatLiteralToken: case SyntaxKind.StringLiteralToken: case SyntaxKind.IdentifierToken: case SyntaxKind.CompileKeyword: return(true); default: return(SyntaxFacts.IsPrefixUnaryExpression(tk) || (SyntaxFacts.IsPredefinedType(Current) && tk != SyntaxKind.VoidKeyword && Lookahead.Kind == SyntaxKind.OpenParenToken) || SyntaxFacts.IsAnyUnaryExpression(tk) || SyntaxFacts.IsBinaryExpression(tk) || SyntaxFacts.IsAssignmentExpression(tk)); } }
public static bool IsAnyAssignExpression(this SyntaxNode node) => SyntaxFacts.IsAssignmentExpression(node.Kind());
private ExpressionSyntax ParseSubExpression(uint precedence) { if (Current.Kind == SyntaxKind.CompileKeyword) { var compile = Match(SyntaxKind.CompileKeyword); var shaderTarget = Match(SyntaxKind.IdentifierToken); var shaderFunctionName = ParseIdentifier(); var shaderFunction = new FunctionInvocationExpressionSyntax(shaderFunctionName, ParseParenthesizedArgumentList(false)); return(new CompileExpressionSyntax(compile, shaderTarget, shaderFunction)); } ExpressionSyntax leftOperand; SyntaxKind opKind; // No left operand, so we need to parse one -- possibly preceded by a // unary operator. var tk = Current.Kind; if (SyntaxFacts.IsPrefixUnaryExpression(tk)) { opKind = SyntaxFacts.GetPrefixUnaryExpression(tk); leftOperand = ParsePrefixUnaryExpression(opKind); } else { // Not a unary operator - get a primary expression. leftOperand = ParseTerm(); } while (true) { // We either have a binary or assignment or compound operator here, or we're finished. tk = Current.Kind; ExpressionOperatorType operatorType; if (SyntaxFacts.IsBinaryExpression(tk) && (!_greaterThanTokenIsNotOperator || tk != SyntaxKind.GreaterThanToken) && (tk != SyntaxKind.GreaterThanToken || !_allowGreaterThanTokenAroundRhsExpression || Lookahead.Kind != SyntaxKind.SemiToken)) { operatorType = ExpressionOperatorType.BinaryExpression; opKind = SyntaxFacts.GetBinaryExpression(tk); } else if (SyntaxFacts.IsAssignmentExpression(tk)) { operatorType = ExpressionOperatorType.AssignmentExpression; opKind = SyntaxFacts.GetAssignmentExpression(tk); } else if (tk == SyntaxKind.CommaToken && CommaIsSeparatorStack.Peek() == false) { operatorType = ExpressionOperatorType.CompoundExpression; opKind = SyntaxKind.CompoundExpression; } else { break; } var newPrecedence = SyntaxFacts.GetOperatorPrecedence(opKind); Debug.Assert(newPrecedence > 0); // All binary operators must have precedence > 0! // Check the precedence to see if we should "take" this operator if (newPrecedence < precedence) { break; } // Same precedence, but not right-associative -- deal with this "later" if (newPrecedence == precedence && !SyntaxFacts.IsRightAssociative(opKind)) { break; } // Precedence is okay, so we'll "take" this operator. var opToken = NextToken(); SyntaxToken lessThanToken = null; if (operatorType == ExpressionOperatorType.AssignmentExpression && _allowGreaterThanTokenAroundRhsExpression) { lessThanToken = NextTokenIf(SyntaxKind.LessThanToken); } var rightOperand = ParseSubExpression(newPrecedence); SyntaxToken greaterThanToken = null; if (lessThanToken != null) { greaterThanToken = NextTokenIf(SyntaxKind.GreaterThanToken); } switch (operatorType) { case ExpressionOperatorType.BinaryExpression: leftOperand = new BinaryExpressionSyntax(opKind, leftOperand, opToken, rightOperand); break; case ExpressionOperatorType.AssignmentExpression: leftOperand = new AssignmentExpressionSyntax(opKind, leftOperand, opToken, lessThanToken, rightOperand, greaterThanToken); break; case ExpressionOperatorType.CompoundExpression: leftOperand = new CompoundExpressionSyntax(opKind, leftOperand, opToken, rightOperand); break; default: throw new ArgumentOutOfRangeException(); } } var conditionalPrecedence = SyntaxFacts.GetOperatorPrecedence(SyntaxKind.ConditionalExpression); if (tk == SyntaxKind.QuestionToken && precedence <= conditionalPrecedence) { var questionToken = NextToken(); var colonLeft = ParseSubExpression(conditionalPrecedence); var colon = Match(SyntaxKind.ColonToken); var colonRight = ParseSubExpression(conditionalPrecedence); leftOperand = new ConditionalExpressionSyntax(leftOperand, questionToken, colonLeft, colon, colonRight); } return(leftOperand); }
public static bool IsAnyAssignExpression(this SyntaxNode node) { return(SyntaxFacts.IsAssignmentExpression(node.CSharpKind())); }