Skip to content

Commit b29c88b

Browse files
sharwellsharwell
authored
Merge pull request #3011 from sharwell/csharp8-lightup
Implement part of the C# 8 lightup layer
2 parents 1b968a5 + 9847a55 commit b29c88b

35 files changed

+2844
-2
lines changed

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/CommonForEachStatementSyntaxWrapperTests.cs

+164
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using System;
7+
using Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using StyleCop.Analyzers.Helpers;
11+
using StyleCop.Analyzers.Lightup;
12+
using Xunit;
13+
14+
public class CommonForEachStatementSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.AwaitKeyword);
23+
Assert.Throws<NullReferenceException>(() => wrapper.ForEachKeyword);
24+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
25+
Assert.Throws<NullReferenceException>(() => wrapper.InKeyword);
26+
Assert.Throws<NullReferenceException>(() => wrapper.Expression);
27+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
28+
Assert.Throws<NullReferenceException>(() => wrapper.Statement);
29+
Assert.Throws<NullReferenceException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
30+
Assert.Throws<NullReferenceException>(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
31+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
32+
Assert.Throws<NullReferenceException>(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword)));
33+
Assert.Throws<NullReferenceException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
34+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
35+
Assert.Throws<NullReferenceException>(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement()));
36+
}
37+
38+
[Fact]
39+
public void TestWrapperIdentity()
40+
{
41+
var syntaxNode = this.CreateForEachStatement();
42+
Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachStatement));
43+
44+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
45+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
46+
}
47+
48+
[Fact]
49+
public void TestAwaitKeyword()
50+
{
51+
var syntaxNode = this.CreateForEachStatement();
52+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
53+
Assert.Equal(default, wrapper.AwaitKeyword);
54+
55+
Assert.Throws<NotSupportedException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
56+
}
57+
58+
[Fact]
59+
public void TestForEachKeyword()
60+
{
61+
var syntaxNode = this.CreateForEachStatement();
62+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
63+
Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword);
64+
65+
Assert.Throws<NotSupportedException>(() => wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword))));
66+
}
67+
68+
[Fact]
69+
public void TestOpenParenToken()
70+
{
71+
var syntaxNode = this.CreateForEachStatement();
72+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
73+
Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken);
74+
75+
Assert.Throws<NotSupportedException>(() => wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken))));
76+
}
77+
78+
[Fact]
79+
public void TestInKeyword()
80+
{
81+
var syntaxNode = this.CreateForEachStatement();
82+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
83+
Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword);
84+
85+
Assert.Throws<NotSupportedException>(() => wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword))));
86+
}
87+
88+
[Fact]
89+
public void TestExpression()
90+
{
91+
var syntaxNode = this.CreateForEachStatement();
92+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
93+
Assert.Same(syntaxNode.Expression, wrapper.Expression);
94+
95+
Assert.Throws<NotSupportedException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))));
96+
}
97+
98+
[Fact]
99+
public void TestCloseParenToken()
100+
{
101+
var syntaxNode = this.CreateForEachStatement();
102+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
103+
Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken);
104+
105+
Assert.Throws<NotSupportedException>(() => wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken))));
106+
}
107+
108+
[Fact]
109+
public void TestStatement()
110+
{
111+
var syntaxNode = this.CreateForEachStatement();
112+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
113+
Assert.Same(syntaxNode.Statement, wrapper.Statement);
114+
115+
Assert.Throws<NotSupportedException>(() => wrapper.WithStatement(SyntaxFactory.Block()));
116+
}
117+
118+
[Fact]
119+
public void TestIsInstance()
120+
{
121+
Assert.False(CommonForEachStatementSyntaxWrapper.IsInstance(null));
122+
Assert.False(CommonForEachStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
123+
124+
var syntaxNode = this.CreateForEachStatement();
125+
Assert.True(CommonForEachStatementSyntaxWrapper.IsInstance(syntaxNode));
126+
}
127+
128+
[Fact]
129+
public void TestConversionsNull()
130+
{
131+
var syntaxNode = default(SyntaxNode);
132+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
133+
134+
StatementSyntax syntax = wrapper;
135+
Assert.Null(syntax);
136+
}
137+
138+
[Fact]
139+
public void TestConversions()
140+
{
141+
var syntaxNode = this.CreateForEachStatement();
142+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
143+
144+
StatementSyntax syntax = wrapper;
145+
Assert.Same(syntaxNode, syntax);
146+
}
147+
148+
[Fact]
149+
public void TestInvalidConversion()
150+
{
151+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
152+
Assert.Throws<InvalidCastException>(() => (CommonForEachStatementSyntaxWrapper)syntaxNode);
153+
}
154+
155+
private ForEachStatementSyntax CreateForEachStatement()
156+
{
157+
return SyntaxFactory.ForEachStatement(
158+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
159+
"x",
160+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
161+
SyntaxFactory.EmptyStatement());
162+
}
163+
}
164+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/LanguageVersionExTestsCSharp7.cs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.Lightup;
7+
8+
public class LanguageVersionExTestsCSharp7 : LanguageVersionExTests
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/MethodKindExTestsCSharp7.cs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.Lightup;
7+
8+
public class MethodKindExTestsCSharp7 : MethodKindExTests
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/SyntaxKindExTestsCSharp7.cs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.Lightup;
7+
8+
public class SyntaxKindExTestsCSharp7 : SyntaxKindExTests
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/CommonForEachStatementSyntaxWrapperTests.cs

+187
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,187 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp8.Lightup
5+
{
6+
using System;
7+
using Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using StyleCop.Analyzers.Helpers;
11+
using StyleCop.Analyzers.Lightup;
12+
using Xunit;
13+
14+
public class CommonForEachStatementSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.AwaitKeyword);
23+
Assert.Throws<NullReferenceException>(() => wrapper.ForEachKeyword);
24+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
25+
Assert.Throws<NullReferenceException>(() => wrapper.InKeyword);
26+
Assert.Throws<NullReferenceException>(() => wrapper.Expression);
27+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
28+
Assert.Throws<NullReferenceException>(() => wrapper.Statement);
29+
Assert.Throws<NullReferenceException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
30+
Assert.Throws<NullReferenceException>(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
31+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
32+
Assert.Throws<NullReferenceException>(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword)));
33+
Assert.Throws<NullReferenceException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
34+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
35+
Assert.Throws<NullReferenceException>(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement()));
36+
}
37+
38+
[Fact]
39+
public void TestWrapperIdentity()
40+
{
41+
var syntaxNode = this.CreateForEachStatement();
42+
Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachStatement));
43+
44+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
45+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
46+
}
47+
48+
[Fact]
49+
public void TestAwaitKeyword()
50+
{
51+
var syntaxNode = this.CreateForEachStatement();
52+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
53+
Assert.Equal(default, wrapper.AwaitKeyword);
54+
55+
wrapper = wrapper.WithAwaitKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
56+
Assert.NotNull(wrapper.SyntaxNode);
57+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
58+
Assert.False(syntaxNode.AwaitKeyword.IsEquivalentTo(wrapper.AwaitKeyword));
59+
}
60+
61+
[Fact]
62+
public void TestForEachKeyword()
63+
{
64+
var syntaxNode = this.CreateForEachStatement();
65+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
66+
Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword);
67+
68+
wrapper = wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
69+
Assert.NotNull(wrapper.SyntaxNode);
70+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
71+
Assert.False(syntaxNode.ForEachKeyword.IsEquivalentTo(wrapper.ForEachKeyword));
72+
}
73+
74+
[Fact]
75+
public void TestOpenParenToken()
76+
{
77+
var syntaxNode = this.CreateForEachStatement();
78+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
79+
Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken);
80+
81+
wrapper = wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
82+
Assert.NotNull(wrapper.SyntaxNode);
83+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
84+
Assert.False(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken));
85+
}
86+
87+
[Fact]
88+
public void TestInKeyword()
89+
{
90+
var syntaxNode = this.CreateForEachStatement();
91+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
92+
Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword);
93+
94+
wrapper = wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword)));
95+
Assert.NotNull(wrapper.SyntaxNode);
96+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
97+
Assert.False(syntaxNode.InKeyword.IsEquivalentTo(wrapper.InKeyword));
98+
}
99+
100+
[Fact]
101+
public void TestExpression()
102+
{
103+
var syntaxNode = this.CreateForEachStatement();
104+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
105+
Assert.Same(syntaxNode.Expression, wrapper.Expression);
106+
107+
wrapper = wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
108+
Assert.NotNull(wrapper.SyntaxNode);
109+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
110+
Assert.NotSame(syntaxNode.Expression, wrapper.Expression);
111+
Assert.False(syntaxNode.Expression.IsEquivalentTo(wrapper.Expression));
112+
}
113+
114+
[Fact]
115+
public void TestCloseParenToken()
116+
{
117+
var syntaxNode = this.CreateForEachStatement();
118+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
119+
Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken);
120+
121+
wrapper = wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
122+
Assert.NotNull(wrapper.SyntaxNode);
123+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
124+
Assert.False(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken));
125+
}
126+
127+
[Fact]
128+
public void TestStatement()
129+
{
130+
var syntaxNode = this.CreateForEachStatement();
131+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
132+
Assert.Same(syntaxNode.Statement, wrapper.Statement);
133+
134+
wrapper = wrapper.WithStatement(SyntaxFactory.Block());
135+
Assert.NotNull(wrapper.SyntaxNode);
136+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
137+
Assert.NotSame(syntaxNode.Statement, wrapper.Statement);
138+
Assert.False(syntaxNode.Statement.IsEquivalentTo(wrapper.Statement));
139+
}
140+
141+
[Fact]
142+
public void TestIsInstance()
143+
{
144+
Assert.False(CommonForEachStatementSyntaxWrapper.IsInstance(null));
145+
Assert.False(CommonForEachStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
146+
147+
var syntaxNode = this.CreateForEachStatement();
148+
Assert.True(CommonForEachStatementSyntaxWrapper.IsInstance(syntaxNode));
149+
}
150+
151+
[Fact]
152+
public void TestConversionsNull()
153+
{
154+
var syntaxNode = default(SyntaxNode);
155+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
156+
157+
StatementSyntax syntax = wrapper;
158+
Assert.Null(syntax);
159+
}
160+
161+
[Fact]
162+
public void TestConversions()
163+
{
164+
var syntaxNode = this.CreateForEachStatement();
165+
var wrapper = (CommonForEachStatementSyntaxWrapper)syntaxNode;
166+
167+
StatementSyntax syntax = wrapper;
168+
Assert.Same(syntaxNode, syntax);
169+
}
170+
171+
[Fact]
172+
public void TestInvalidConversion()
173+
{
174+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
175+
Assert.Throws<InvalidCastException>(() => (CommonForEachStatementSyntaxWrapper)syntaxNode);
176+
}
177+
178+
private ForEachStatementSyntax CreateForEachStatement()
179+
{
180+
return SyntaxFactory.ForEachStatement(
181+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
182+
"x",
183+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
184+
SyntaxFactory.EmptyStatement());
185+
}
186+
}
187+
}

0 commit comments

Comments
 (0)