private static bool TryGetBinaryExpression(CSS.IfStatementSyntax node, out CSS.BinaryExpressionSyntax binaryExpressionSyntax, CS.SyntaxKind notEqualsExpression, CS.SyntaxKind operand) { binaryExpressionSyntax = TrimParenthesis(node) as CSS.BinaryExpressionSyntax; return(binaryExpressionSyntax != null && binaryExpressionSyntax.IsKind(notEqualsExpression) && (binaryExpressionSyntax.Left.IsKind(operand) || binaryExpressionSyntax.Right.IsKind(operand))); }
private static CSS.ExpressionSyntax TrimParenthesis(CSS.IfStatementSyntax node) { var condition = node.Condition; while (condition is CSS.ParenthesizedExpressionSyntax pExp) { condition = pExp.Expression; } return(condition); }
bool TryConvertRaiseEvent(CSS.IfStatementSyntax node, out IdentifierNameSyntax name, List <ArgumentSyntax> arguments) { name = null; var condition = node.Condition; while (condition is CSS.ParenthesizedExpressionSyntax) { condition = ((CSS.ParenthesizedExpressionSyntax)condition).Expression; } if (!(condition is CSS.BinaryExpressionSyntax)) { return(false); } var be = (CSS.BinaryExpressionSyntax)condition; if (!be.IsKind(CS.SyntaxKind.NotEqualsExpression) || (!be.Left.IsKind(CS.SyntaxKind.NullLiteralExpression) && !be.Right.IsKind(CS.SyntaxKind.NullLiteralExpression))) { return(false); } CSS.ExpressionStatementSyntax singleStatement; if (node.Statement is CSS.BlockSyntax) { var block = ((CSS.BlockSyntax)node.Statement); if (block.Statements.Count != 1) { return(false); } singleStatement = block.Statements[0] as CSS.ExpressionStatementSyntax; } else { singleStatement = node.Statement as CSS.ExpressionStatementSyntax; } if (singleStatement == null || !(singleStatement.Expression is CSS.InvocationExpressionSyntax)) { return(false); } var possibleEventName = GetPossibleEventName(be.Left) ?? GetPossibleEventName(be.Right); if (possibleEventName == null) { return(false); } var invocation = (CSS.InvocationExpressionSyntax)singleStatement.Expression; var invocationName = GetPossibleEventName(invocation.Expression); if (possibleEventName != invocationName) { return(false); } name = SyntaxFactory.IdentifierName(possibleEventName); arguments.AddRange(invocation.ArgumentList.Arguments.Select(a => (ArgumentSyntax)a.Accept(_nodesVisitor))); return(true); }
public override SyntaxList <StatementSyntax> VisitIfStatement(CSS.IfStatementSyntax node) { IdentifierNameSyntax name; List <ArgumentSyntax> arguments = new List <ArgumentSyntax>(); StatementSyntax stmt; if (node.Else == null && TryConvertRaiseEvent(node, out name, arguments)) { stmt = SyntaxFactory.RaiseEventStatement(name, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))); return(SyntaxFactory.SingletonList(stmt)); } var elseIfBlocks = new List <ElseIfBlockSyntax>(); ElseBlockSyntax elseBlock = null; CollectElseBlocks(node, elseIfBlocks, ref elseBlock); if (node.Statement is CSS.BlockSyntax) { stmt = SyntaxFactory.MultiLineIfBlock( SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), ConvertBlock(node.Statement), SyntaxFactory.List(elseIfBlocks), elseBlock ); } else { if (elseIfBlocks.Any() || elseBlock != null || !IsSimpleStatement(node.Statement)) { stmt = SyntaxFactory.MultiLineIfBlock( SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), ConvertBlock(node.Statement), SyntaxFactory.List(elseIfBlocks), elseBlock ); } else { stmt = SyntaxFactory.SingleLineIfStatement( (ExpressionSyntax)node.Condition.Accept(_nodesVisitor), ConvertBlock(node.Statement), null ).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)); } } return(SyntaxFactory.SingletonList(stmt)); }
void CollectElseBlocks(CSS.IfStatementSyntax node, List <ElseIfBlockSyntax> elseIfBlocks, ref ElseBlockSyntax elseBlock) { if (node.Else == null) { return; } if (node.Else.Statement is CSS.IfStatementSyntax) { var elseIf = (CSS.IfStatementSyntax)node.Else.Statement; if (elseIf.Statement is CSS.BlockSyntax) { var block = (CSS.BlockSyntax)elseIf.Statement; elseIfBlocks.Add( SyntaxFactory.ElseIfBlock( SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), SyntaxFactory.List(block.Statements.SelectMany(s => s.Accept(this))) ) ); } else { elseIfBlocks.Add( SyntaxFactory.ElseIfBlock( SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), elseIf.Statement.Accept(this) ) ); } CollectElseBlocks(elseIf, elseIfBlocks, ref elseBlock); } else if (node.Else.Statement is CSS.BlockSyntax) { var block = (CSS.BlockSyntax)node.Else.Statement; elseBlock = SyntaxFactory.ElseBlock(SyntaxFactory.List(block.Statements.SelectMany(s => s.Accept(this)))); } else { elseBlock = SyntaxFactory.ElseBlock(SyntaxFactory.List(node.Else.Statement.Accept(this))); } }
void CollectElseBlocks(CSS.IfStatementSyntax node, List <ElseIfBlockSyntax> elseIfBlocks, ref ElseBlockSyntax elseBlock) { if (node.Else == null) { return; } if (node.Else.Statement is CSS.IfStatementSyntax) { var elseIf = (CSS.IfStatementSyntax)node.Else.Statement; elseIfBlocks.Add( SyntaxFactory.ElseIfBlock( SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), ConvertBlock(elseIf.Statement) ) ); CollectElseBlocks(elseIf, elseIfBlocks, ref elseBlock); } else { elseBlock = SyntaxFactory.ElseBlock(ConvertBlock(node.Else.Statement)); } }
public override SyntaxList <StatementSyntax> VisitIfStatement(CSS.IfStatementSyntax node) { StatementSyntax stmt; var elseIfBlocks = new List <ElseIfBlockSyntax>(); ElseBlockSyntax elseBlock = null; CollectElseBlocks(node, elseIfBlocks, ref elseBlock); if (node.Statement is CSS.BlockSyntax) { var b = (CSS.BlockSyntax)node.Statement; stmt = SyntaxFactory.MultiLineIfBlock( SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), SyntaxFactory.List(b.Statements.SelectMany(s => s.Accept(this))), SyntaxFactory.List(elseIfBlocks), elseBlock ); } else { if (elseIfBlocks.Any()) { stmt = SyntaxFactory.MultiLineIfBlock( SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), node.Statement.Accept(this), SyntaxFactory.List(elseIfBlocks), elseBlock ); } else { stmt = SyntaxFactory.SingleLineIfStatement( (ExpressionSyntax)node.Condition.Accept(nodesVisitor), node.Statement.Accept(this), SyntaxFactory.SingleLineElseClause(elseBlock.Statements) ).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)); } } return(SyntaxFactory.SingletonList <StatementSyntax>(stmt)); }
public override SyntaxList <VB.Syntax.StatementSyntax> VisitIfStatement(CS.Syntax.IfStatementSyntax node) { VB.Syntax.IfStatementSyntax ifStatement = VB.SyntaxFactory.IfStatement( VB.SyntaxFactory.Token(VB.SyntaxKind.IfKeyword), nodeVisitor.VisitExpression(node.Condition), VB.SyntaxFactory.Token(VB.SyntaxKind.ThenKeyword)); List <VB.Syntax.ElseIfBlockSyntax> elseIfBlocks = new List <VB.Syntax.ElseIfBlockSyntax>(); ElseClauseSyntax currentElseClause = node.Else; while (currentElseClause != null) { if (!currentElseClause.Statement.IsKind(CS.SyntaxKind.IfStatement)) { break; } IfStatementSyntax nestedIf = (CS.Syntax.IfStatementSyntax)currentElseClause.Statement; currentElseClause = nestedIf.Else; VB.Syntax.ElseIfStatementSyntax elseIfStatement = VB.SyntaxFactory.ElseIfStatement( VB.SyntaxFactory.Token(VB.SyntaxKind.ElseIfKeyword), nodeVisitor.VisitExpression(nestedIf.Condition), VB.SyntaxFactory.Token(VB.SyntaxKind.ThenKeyword)); VB.Syntax.ElseIfBlockSyntax elseIfBlock = VB.SyntaxFactory.ElseIfBlock( elseIfStatement, Visit(nestedIf.Statement)); elseIfBlocks.Add(elseIfBlock); } return(List <VB.Syntax.StatementSyntax>( VB.SyntaxFactory.MultiLineIfBlock( ifStatement, Visit(node.Statement), List <VB.Syntax.ElseIfBlockSyntax>(elseIfBlocks), currentElseClause == null ? null : nodeVisitor.Visit <VB.Syntax.ElseBlockSyntax>(currentElseClause)))); }
bool TryConvertIfNotNullRaiseEvent(CSS.IfStatementSyntax node, out StatementSyntax raiseEventStatement) { raiseEventStatement = null; return(TryGetBinaryExpression(node, out var comparisonExpression, CS.SyntaxKind.NotEqualsExpression, CS.SyntaxKind.NullLiteralExpression) && TryConvertRaiseEvent(node.Statement, comparisonExpression, ref raiseEventStatement)); }
internal static SyntaxToken GetFirstExcludedToken(StatementSyntax statement) { Debug.Assert(statement != null); switch (statement.Kind()) { case SyntaxKind.Block: return(((BlockSyntax)statement).CloseBraceToken); case SyntaxKind.BreakStatement: return(((BreakStatementSyntax)statement).SemicolonToken); case SyntaxKind.CheckedStatement: case SyntaxKind.UncheckedStatement: return(((CheckedStatementSyntax)statement).Block.CloseBraceToken); case SyntaxKind.ContinueStatement: return(((ContinueStatementSyntax)statement).SemicolonToken); case SyntaxKind.LocalDeclarationStatement: return(((LocalDeclarationStatementSyntax)statement).SemicolonToken); case SyntaxKind.DoStatement: return(((DoStatementSyntax)statement).SemicolonToken); case SyntaxKind.EmptyStatement: return(((EmptyStatementSyntax)statement).SemicolonToken); case SyntaxKind.ExpressionStatement: return(((ExpressionStatementSyntax)statement).SemicolonToken); case SyntaxKind.FixedStatement: return(GetFirstExcludedToken(((FixedStatementSyntax)statement).Statement)); case SyntaxKind.ForEachStatement: case SyntaxKind.ForEachVariableStatement: return(GetFirstExcludedToken(((CommonForEachStatementSyntax)statement).Statement)); case SyntaxKind.ForStatement: return(GetFirstExcludedToken(((ForStatementSyntax)statement).Statement)); case SyntaxKind.GotoDefaultStatement: case SyntaxKind.GotoCaseStatement: case SyntaxKind.GotoStatement: return(((GotoStatementSyntax)statement).SemicolonToken); case SyntaxKind.IfStatement: IfStatementSyntax ifStmt = (IfStatementSyntax)statement; ElseClauseSyntax elseOpt = ifStmt.Else; return(GetFirstExcludedToken(elseOpt == null ? ifStmt.Statement : elseOpt.Statement)); case SyntaxKind.LabeledStatement: return(GetFirstExcludedToken(((LabeledStatementSyntax)statement).Statement)); case SyntaxKind.LockStatement: return(GetFirstExcludedToken(((LockStatementSyntax)statement).Statement)); case SyntaxKind.ReturnStatement: return(((ReturnStatementSyntax)statement).SemicolonToken); case SyntaxKind.SwitchStatement: return(((SwitchStatementSyntax)statement).CloseBraceToken); case SyntaxKind.ThrowStatement: return(((ThrowStatementSyntax)statement).SemicolonToken); case SyntaxKind.TryStatement: TryStatementSyntax tryStmt = (TryStatementSyntax)statement; FinallyClauseSyntax finallyClause = tryStmt.Finally; if (finallyClause != null) { return(finallyClause.Block.CloseBraceToken); } CatchClauseSyntax lastCatch = tryStmt.Catches.LastOrDefault(); if (lastCatch != null) { return(lastCatch.Block.CloseBraceToken); } return(tryStmt.Block.CloseBraceToken); case SyntaxKind.UnsafeStatement: return(((UnsafeStatementSyntax)statement).Block.CloseBraceToken); case SyntaxKind.UsingStatement: return(GetFirstExcludedToken(((UsingStatementSyntax)statement).Statement)); case SyntaxKind.WhileStatement: return(GetFirstExcludedToken(((WhileStatementSyntax)statement).Statement)); case SyntaxKind.YieldReturnStatement: case SyntaxKind.YieldBreakStatement: return(((YieldStatementSyntax)statement).SemicolonToken); case SyntaxKind.LocalFunctionStatement: LocalFunctionStatementSyntax localFunctionStmt = (LocalFunctionStatementSyntax)statement; if (localFunctionStmt.Body != null) { return(GetFirstExcludedToken(localFunctionStmt.Body)); } if (localFunctionStmt.SemicolonToken != default(SyntaxToken)) { return(localFunctionStmt.SemicolonToken); } return(localFunctionStmt.ParameterList.GetLastToken()); default: throw ExceptionUtilities.UnexpectedValue(statement.Kind()); } }