public void TestRedConsecutiveSeparators() { //there are omitted array size expressions between the commas var input = "int[,,]a;"; //NB: no whitespace, since it would be deleted bool first = true; var rewriter = new RedRewriter( rewriteNode: node => { if (node != null && node.IsKind(SyntaxKind.OmittedArraySizeExpression) && first) { first = false; return(null); } return(node); } ); Exception caught = null; try { TestRed(input, "", rewriter, isExpr: false); } catch (Exception e) { caught = e; } Assert.NotNull(caught); Assert.True(caught is InvalidOperationException); }
public void TestRedSeparatedDeleteAll() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted //delete all type arguments, should clear the intervening commas var rewriter = new RedRewriter( rewriteNode: node => (node.IsKind(SyntaxKind.IdentifierName) && node.ToString() != "A") ? null : node ); Exception caught = null; try { TestRed(input, "", rewriter, isExpr: true); } catch (Exception e) { caught = e; } Assert.NotNull(caught); Assert.True(caught is InvalidOperationException); }
public void TestRedSeparatedDeleteNone() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: true); }
public void TestRedTokenDeleteNone() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTriviaDeleteNone() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteNone() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedSeparatedDeleteNone() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: true); }
private static void TestRed(string input, string output, RedRewriter rewriter, bool isExpr) { var red = isExpr ? (CSharpSyntaxNode)SyntaxFactory.ParseExpression(input) : SyntaxFactory.ParseStatement(input); Assert.False(red.ContainsDiagnostics); var result = rewriter.Visit(red); Assert.Equal(input == output, ReferenceEquals(red, result)); Assert.Equal(output, result.ToFullString()); }
public void TestRedTriviaDeleteAll() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = "a();"; //delete all trivia var rewriter = new RedRewriter(rewriteTrivia: trivia => default(SyntaxTrivia)); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTokenDeleteAll() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = "x=new[]{{{}}};"; //delete all commas var rewriter = new RedRewriter(rewriteToken: token => (token.Kind() == SyntaxKind.CommaToken) ? default(SyntaxToken) : token); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTriviaDeleteSome() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = "a();//comment"; //delete all whitespace trivia (leave comments) var rewriter = new RedRewriter(rewriteTrivia: trivia => trivia.Kind() == SyntaxKind.WhitespaceTrivia ? default(SyntaxTrivia) : trivia); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteSome() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = "{A();C();}"; //delete the middle statement var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.ExpressionStatement) && node.ToString().Contains("B")) ? null : node); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteAll() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = "{}"; //delete all statements var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.ExpressionStatement)) ? null : node); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedSeparatedDeleteLast() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted var output = "A<B,C,>"; //delete the last type argument (should clear the *preceding* comma) var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.IdentifierName) && node.ToString() == "D") ? null : node); TestRed(input, output, rewriter, isExpr: true); }
public void RewriteMissingIdentifierInExpressionStatement_WithSyntaxTree() { var tree1 = SyntaxFactory.ParseSyntaxTree( "class C { static void Main() { if (true) } }" ); var ifStmt1 = tree1 .GetCompilationUnitRoot() .DescendantNodes() .OfType <IfStatementSyntax>() .Single(); var exprStmt1 = (ExpressionStatementSyntax)ifStmt1.Statement; var expr1 = (IdentifierNameSyntax)exprStmt1.Expression; var token1 = expr1.Identifier; Assert.Equal(tree1, expr1.SyntaxTree); Assert.True(expr1.IsMissing); Assert.True(expr1.ContainsDiagnostics); Assert.True(token1.IsMissing); Assert.False(token1.ContainsDiagnostics); var trivia = SyntaxFactory.ParseTrailingTrivia(" "); var rewriter = new RedRewriter( rewriteToken: tok => tok.Kind() == SyntaxKind.IdentifierToken ? tok.WithLeadingTrivia(trivia) : tok ); var ifStmt2 = (IfStatementSyntax)rewriter.Visit(ifStmt1); var exprStmt2 = (ExpressionStatementSyntax)ifStmt2.Statement; var expr2 = (IdentifierNameSyntax)exprStmt2.Expression; var token2 = expr2.Identifier; Assert.NotEqual(expr1, expr2); Assert.NotNull(expr2.SyntaxTree); Assert.False( expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?" ); Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot()); Assert.True(expr2.IsMissing); Assert.False(expr2.ContainsDiagnostics); //gone after rewrite Assert.NotEqual(token1, token2); Assert.True(token2.IsMissing); Assert.False(token2.ContainsDiagnostics); Assert.True(IsStatementExpression(expr1)); Assert.True(IsStatementExpression(expr2)); }
public void TestRedTokenDeleteSome() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = "x=new[,]{{{}}};"; //delete one comma bool first = true; var rewriter = new RedRewriter(rewriteToken: token => { if (token.Kind() == SyntaxKind.CommaToken && first) { first = false; return(default(SyntaxToken)); } return(token); }); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedSeparatedDeleteSome() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted //delete the middle type argument (should clear the following comma) var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.IdentifierName) && node.ToString() == "C") ? null : node); Exception caught = null; try { TestRed(input, "", rewriter, isExpr: true); } catch (Exception e) { caught = e; } Assert.NotNull(caught); Assert.Equal(true, caught is InvalidOperationException); }
public void RewriteMissingIdentiferInExpressionStatement_ImplicitlyCreatedSyntaxTree() { var ifStmt1 = (IfStatementSyntax)SyntaxFactory.ParseStatement("if (true)"); var exprStmt1 = (ExpressionStatementSyntax)ifStmt1.Statement; var expr1 = (IdentifierNameSyntax)exprStmt1.Expression; var token1 = expr1.Identifier; Assert.NotNull(expr1.SyntaxTree); Assert.False(expr1.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); Assert.Same(ifStmt1, expr1.SyntaxTree.GetRoot()); Assert.True(expr1.IsMissing); Assert.True(expr1.ContainsDiagnostics); Assert.True(token1.IsMissing); Assert.False(token1.ContainsDiagnostics); var trivia = SyntaxFactory.ParseTrailingTrivia(" "); var rewriter = new RedRewriter(rewriteToken: tok => tok.CSharpKind() == SyntaxKind.IdentifierToken ? tok.WithLeadingTrivia(trivia) : tok); var ifStmt2 = (IfStatementSyntax)rewriter.Visit(ifStmt1); var exprStmt2 = (ExpressionStatementSyntax)ifStmt2.Statement; var expr2 = (IdentifierNameSyntax)exprStmt2.Expression; var token2 = expr2.Identifier; Assert.NotEqual(expr1, expr2); Assert.NotNull(expr2.SyntaxTree); Assert.False(expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot()); Assert.True(expr2.IsMissing); Assert.False(expr2.ContainsDiagnostics); //gone after rewrite Assert.NotEqual(token1, token2); Assert.True(token2.IsMissing); Assert.False(token2.ContainsDiagnostics); Assert.True(IsStatementExpression(expr1.Green)); Assert.True(IsStatementExpression(expr2.Green)); }
public void RewriteMissingIdentiferInExpressionStatement_ImplicitlyCreatedSyntaxTree() { var ifStmt1 = (IfStatementSyntax)SyntaxFactory.ParseStatement("if (true)"); var exprStmt1 = (ExpressionStatementSyntax)ifStmt1.Statement; var expr1 = (IdentifierNameSyntax)exprStmt1.Expression; var token1 = expr1.Identifier; Assert.NotNull(expr1.SyntaxTree); Assert.False(expr1.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); Assert.Same(ifStmt1, expr1.SyntaxTree.GetRoot()); Assert.True(expr1.IsMissing); Assert.True(expr1.ContainsDiagnostics); Assert.True(token1.IsMissing); Assert.False(token1.ContainsDiagnostics); var trivia = SyntaxFactory.ParseTrailingTrivia(" "); var rewriter = new RedRewriter(rewriteToken: tok => tok.Kind() == SyntaxKind.IdentifierToken ? tok.WithLeadingTrivia(trivia) : tok); var ifStmt2 = (IfStatementSyntax)rewriter.Visit(ifStmt1); var exprStmt2 = (ExpressionStatementSyntax)ifStmt2.Statement; var expr2 = (IdentifierNameSyntax)exprStmt2.Expression; var token2 = expr2.Identifier; Assert.NotEqual(expr1, expr2); Assert.NotNull(expr2.SyntaxTree); Assert.False(expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot()); Assert.True(expr2.IsMissing); Assert.False(expr2.ContainsDiagnostics); //gone after rewrite Assert.NotEqual(token1, token2); Assert.True(token2.IsMissing); Assert.False(token2.ContainsDiagnostics); Assert.True(IsStatementExpression(expr1)); Assert.True(IsStatementExpression(expr2)); }
public void TestRedTokenDeleteNone() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTokenDeleteSome() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = "x=new[,]{{{}}};"; //delete one comma bool first = true; var rewriter = new RedRewriter(rewriteToken: token => { if (token.Kind() == SyntaxKind.CommaToken && first) { first = false; return default(SyntaxToken); } return token; }); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTokenDeleteAll() { //commas in an implicit array creation constitute a SyntaxTokenList var input = "x=new[,,]{{{}}};"; //NB: no whitespace, since it would be deleted var output = "x=new[]{{{}}};"; //delete all commas var rewriter = new RedRewriter(rewriteToken: token => (token.Kind() == SyntaxKind.CommaToken) ? default(SyntaxToken) : token); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTriviaDeleteNone() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTriviaDeleteSome() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = "a();//comment"; //delete all whitespace trivia (leave comments) var rewriter = new RedRewriter(rewriteTrivia: trivia => trivia.Kind() == SyntaxKind.WhitespaceTrivia ? default(SyntaxTrivia) : trivia); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedTriviaDeleteAll() { //whitespace and comments constitute a SyntaxTriviaList var input = " a(); //comment"; //NB: no whitespace, since it would be deleted var output = "a();"; //delete all trivia var rewriter = new RedRewriter(rewriteTrivia: trivia => default(SyntaxTrivia)); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteNone() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = input; var rewriter = new RedRewriter(); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteSome() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = "{A();C();}"; //delete the middle statement var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.ExpressionStatement) && node.ToString().Contains("B")) ? null : node); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedDeleteAll() { //statements in block constitute a SyntaxList var input = "{A();B();C();}"; //NB: no whitespace, since it would be deleted var output = "{}"; //delete all statements var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.ExpressionStatement)) ? null : node); TestRed(input, output, rewriter, isExpr: false); }
public void TestRedConsecutiveSeparators() { //there are omitted array size expressions between the commas var input = "int[,,]a;"; //NB: no whitespace, since it would be deleted bool first = true; var rewriter = new RedRewriter(rewriteNode: node => { if (node != null && node.IsKind(SyntaxKind.OmittedArraySizeExpression) && first) { first = false; return null; } return node; }); Exception caught = null; try { TestRed(input, "", rewriter, isExpr: false); } catch (Exception e) { caught = e; } Assert.NotNull(caught); Assert.Equal(true, caught is InvalidOperationException); }
public void TestRedSeparatedDeleteLast() { //the type argument list is a SeparateSyntaxList var input = "A<B,C,D>"; //NB: no whitespace, since it would be deleted var output = "A<B,C,>"; //delete the last type argument (should clear the *preceding* comma) var rewriter = new RedRewriter(rewriteNode: node => (node.IsKind(SyntaxKind.IdentifierName) && node.ToString() == "D") ? null : node); TestRed(input, output, rewriter, isExpr: true); }
public void RewriteMissingIdentifierInExpressionStatement_WithSyntaxTree() { var tree1 = SyntaxFactory.ParseSyntaxTree("class C { static void Main() { if (true) } }"); var ifStmt1 = tree1.GetCompilationUnitRoot().DescendantNodes().OfType<IfStatementSyntax>().Single(); var exprStmt1 = (ExpressionStatementSyntax)ifStmt1.Statement; var expr1 = (IdentifierNameSyntax)exprStmt1.Expression; var token1 = expr1.Identifier; Assert.Equal(tree1, expr1.SyntaxTree); Assert.True(expr1.IsMissing); Assert.True(expr1.ContainsDiagnostics); Assert.True(token1.IsMissing); Assert.False(token1.ContainsDiagnostics); var trivia = SyntaxFactory.ParseTrailingTrivia(" "); var rewriter = new RedRewriter(rewriteToken: tok => tok.Kind() == SyntaxKind.IdentifierToken ? tok.WithLeadingTrivia(trivia) : tok); var ifStmt2 = (IfStatementSyntax)rewriter.Visit(ifStmt1); var exprStmt2 = (ExpressionStatementSyntax)ifStmt2.Statement; var expr2 = (IdentifierNameSyntax)exprStmt2.Expression; var token2 = expr2.Identifier; Assert.NotEqual(expr1, expr2); Assert.NotNull(expr2.SyntaxTree); Assert.False(expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot()); Assert.True(expr2.IsMissing); Assert.False(expr2.ContainsDiagnostics); //gone after rewrite Assert.NotEqual(token1, token2); Assert.True(token2.IsMissing); Assert.False(token2.ContainsDiagnostics); Assert.True(IsStatementExpression(expr1)); Assert.True(IsStatementExpression(expr2)); }
private static void TestRed(string input, string output, RedRewriter rewriter, bool isExpr) { var red = isExpr ? (CSharpSyntaxNode)SyntaxFactory.ParseExpression(input) : SyntaxFactory.ParseStatement(input); Assert.False(red.ContainsDiagnostics); var result = rewriter.Visit(red); Assert.Equal(input == output, ReferenceEquals(red, result)); Assert.Equal(output, result.ToFullString()); }