C# AssignmentExpressionSyntax.Kind方法代码示例

        internal static bool ParseIfStatement(IfStatementSyntax node, out ExpressionSyntax condition, out ExpressionSyntax target, out AssignmentExpressionSyntax whenTrue, out AssignmentExpressionSyntax whenFalse)
        {
            condition = null;
            target = null;
            whenTrue = null;
            whenFalse = null;

            if (node == null || node.Else == null || node.Parent is IfStatementSyntax || node.Else.Statement is IfStatementSyntax)
                return false;

            condition = node.Condition;
            //make sure to check for multiple statements
            ExpressionStatementSyntax whenTrueExprStatement, whenFalseExprStatement;
            var embeddedBlock = node.Statement as BlockSyntax;
            if (embeddedBlock != null)
            {
                if (embeddedBlock.Statements.Count > 1)
                    return false;
                var childNodes = embeddedBlock.ChildNodes();
                if (childNodes.Count() > 1)
                    return false;
                whenTrueExprStatement = childNodes.OfType<ExpressionStatementSyntax>().FirstOrDefault();
            }
            else
            {
                whenTrueExprStatement = node.Statement as ExpressionStatementSyntax;
            }

            var elseBlock = node.Else.Statement as BlockSyntax;
            if (elseBlock != null)
            {
                if (elseBlock.Statements.Count > 1)
                    return false;
                var childNodes = elseBlock.ChildNodes();
                if (childNodes.Count() > 1)
                    return false;
                whenFalseExprStatement = childNodes.OfType<ExpressionStatementSyntax>().FirstOrDefault();
            }
            else
            {
                whenFalseExprStatement = node.Else.Statement as ExpressionStatementSyntax;
            }

            if (whenTrueExprStatement == null || whenFalseExprStatement == null)
                return false;

            whenTrue = whenTrueExprStatement.Expression as AssignmentExpressionSyntax;
            whenFalse = whenFalseExprStatement.Expression as AssignmentExpressionSyntax;
            if (whenTrue == null || whenFalse == null || whenTrue.Kind() != whenFalse.Kind() ||
                !SyntaxFactory.AreEquivalent(whenTrue.Left, whenFalse.Left))
                return false;

            return true;
        }

		/// <summary>
		///     Normalizes the <paramref name="expression" /> if it represents a compound assignment.
		/// </summary>
		public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax expression)
		{
			expression = (AssignmentExpressionSyntax)base.VisitAssignmentExpression(expression);

			SyntaxKind expressionKind;
			switch (expression.Kind())
			{
				case SyntaxKind.AddAssignmentExpression:
					expressionKind = SyntaxKind.AddExpression;
					break;
				case SyntaxKind.SubtractAssignmentExpression:
					expressionKind = SyntaxKind.SubtractExpression;
					break;
				case SyntaxKind.MultiplyAssignmentExpression:
					expressionKind = SyntaxKind.MultiplyExpression;
					break;
				case SyntaxKind.DivideAssignmentExpression:
					expressionKind = SyntaxKind.DivideExpression;
					break;
				case SyntaxKind.ModuloAssignmentExpression:
					expressionKind = SyntaxKind.ModuloExpression;
					break;
				case SyntaxKind.AndAssignmentExpression:
					expressionKind = SyntaxKind.LogicalAndExpression;
					break;
				case SyntaxKind.ExclusiveOrAssignmentExpression:
					expressionKind = SyntaxKind.ExclusiveOrExpression;
					break;
				case SyntaxKind.OrAssignmentExpression:
					expressionKind = SyntaxKind.LogicalOrExpression;
					break;
				case SyntaxKind.LeftShiftAssignmentExpression:
					expressionKind = SyntaxKind.LeftShiftExpression;
					break;
				case SyntaxKind.RightShiftAssignmentExpression:
					expressionKind = SyntaxKind.RightShiftExpression;
					break;
				default:
					return expression;
			}

			var originalRightHand = (ExpressionSyntax)Visit(expression.Right);
			var parenthesizedExpression = SyntaxFactory.ParenthesizedExpression(originalRightHand).WithLeadingSpace();
			var rightHandExpression = SyntaxFactory.BinaryExpression(expressionKind, expression.Left.WithLeadingSpace(), parenthesizedExpression);
			var simpleAssignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, expression.Left, rightHandExpression);
			return simpleAssignment.WithTrivia(expression);
		}

        private bool TryGenerateAssignment(AssignmentExpressionSyntax binaryExpression)
        {
            var kind = BinaryOperatorKind.None;
            switch (binaryExpression.Kind())
            {
                case SyntaxKind.AddAssignmentExpression:
                    kind = BinaryOperatorKind.AddDelegate;
                    break;
            }

            using (AssignmentTag(kind))
            {
                return TryGenerateExpression(binaryExpression.Left)
                    && TryGenerateExpression(binaryExpression.Right);
            }
        }

 private static bool MightHaveReferenceBetween(SyntaxNode first, AssignmentExpressionSyntax second, List<IdentifierNameSyntax> references)
 {
     return !DifferentStatementsWithSameParent(first, second) ||
            references.Any(reference =>
                reference.SpanStart < second.SpanStart && reference.SpanStart >= first.Span.End) ||
            ReferenceInAssignmentRight(references, second) ||
            ReadWriteAssignment.Contains(second.Kind());
 }

 static IfStatementSyntax CreateForNullCoalescingExpression(AssignmentExpressionSyntax expr, BinaryExpressionSyntax bOp)
 {
     return SyntaxFactory.IfStatement(SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, bOp.Left, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
         SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(expr.Kind(), expr.Left, bOp.Left)),
         SyntaxFactory.ElseClause(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(expr.Kind(), expr.Left, bOp.Right))));
 }

 static IfStatementSyntax CreateForConditionalExpression(AssignmentExpressionSyntax expr, ConditionalExpressionSyntax conditional)
 {
     return SyntaxFactory.IfStatement(
         conditional.Condition,
         SyntaxFactory.ExpressionStatement(
             SyntaxFactory.AssignmentExpression(expr.Kind(), expr.Left, conditional.WhenTrue)
         ),
         SyntaxFactory.ElseClause(
             SyntaxFactory.ExpressionStatement(
                 SyntaxFactory.AssignmentExpression(expr.Kind(), expr.Left, conditional.WhenFalse)
             )
         )
     );
 }

        public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node)
        {
            node = (AssignmentExpressionSyntax)base.VisitAssignmentExpression(node);
            var left = node.Left;
            var right = node.Right;
            var operatorToken = node.OperatorToken;

            if ((transformKind == TransformKind.AddAssignToAssign) && (node.Kind() == SyntaxKind.AddAssignmentExpression))
            {
                var equalsToken = SyntaxFactory.Token(operatorToken.LeadingTrivia, SyntaxKind.EqualsToken, operatorToken.TrailingTrivia);
                var newLeft = left.WithLeadingTrivia(SyntaxFactory.TriviaList());
                var addExpression = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, newLeft, SyntaxFactory.Token(operatorToken.LeadingTrivia, SyntaxKind.PlusToken, operatorToken.TrailingTrivia), right);

                return SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, equalsToken, addExpression);
            }

            return node;
        }