/
CSharpSyntaxFacade.cs
130 lines (101 loc) · 6.34 KB
/
CSharpSyntaxFacade.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*
* SonarAnalyzer for .NET
* Copyright (C) 2015-2023 SonarSource SA
* mailto: contact AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
namespace SonarAnalyzer.Helpers.Facade;
internal sealed class CSharpSyntaxFacade : SyntaxFacade<SyntaxKind>
{
public override SyntaxKind Kind(SyntaxNode node) => node.Kind();
public override ComparisonKind ComparisonKind(SyntaxNode node) =>
node.Kind() switch
{
SyntaxKind.EqualsExpression => Helpers.ComparisonKind.Equals,
SyntaxKind.NotEqualsExpression => Helpers.ComparisonKind.NotEquals,
SyntaxKind.LessThanExpression => Helpers.ComparisonKind.LessThan,
SyntaxKind.LessThanOrEqualExpression => Helpers.ComparisonKind.LessThanOrEqual,
SyntaxKind.GreaterThanExpression => Helpers.ComparisonKind.GreaterThan,
SyntaxKind.GreaterThanOrEqualExpression => Helpers.ComparisonKind.GreaterThanOrEqual,
_ => Helpers.ComparisonKind.None,
};
public override bool IsKind(SyntaxNode node, SyntaxKind kind) => node.IsKind(kind);
public override bool IsKind(SyntaxToken token, SyntaxKind kind) => token.IsKind(kind);
public override bool IsKind(SyntaxTrivia trivia, SyntaxKind kind) => trivia.IsKind(kind);
public override bool IsAnyKind(SyntaxNode node, ISet<SyntaxKind> syntaxKinds) => node.IsAnyKind(syntaxKinds);
public override bool IsAnyKind(SyntaxNode node, params SyntaxKind[] syntaxKinds) => node.IsAnyKind(syntaxKinds);
public override bool IsAnyKind(SyntaxTrivia trivia, params SyntaxKind[] syntaxKinds) => trivia.IsAnyKind(syntaxKinds);
public override bool IsNullLiteral(SyntaxNode node) => node.IsNullLiteral();
public override bool IsKnownAttributeType(SemanticModel model, SyntaxNode attribute, KnownType knownType) =>
AttributeSyntaxExtensions.IsKnownType(Cast<AttributeSyntax>(attribute), knownType, model);
public override IEnumerable<SyntaxNode> ArgumentExpressions(SyntaxNode node) =>
node switch
{
ObjectCreationExpressionSyntax creation => creation.ArgumentList?.Arguments.Select(x => x.Expression) ?? Enumerable.Empty<SyntaxNode>(),
null => Enumerable.Empty<SyntaxNode>(),
var _ when ImplicitObjectCreationExpressionSyntaxWrapper.IsInstance(node)
=> ((ImplicitObjectCreationExpressionSyntaxWrapper)node).ArgumentList?.Arguments.Select(x => x.Expression) ?? Enumerable.Empty<SyntaxNode>(),
_ => throw InvalidOperation(node, nameof(ArgumentExpressions))
};
public override ImmutableArray<SyntaxNode> AssignmentTargets(SyntaxNode assignment) =>
Cast<AssignmentExpressionSyntax>(assignment).AssignmentTargets();
public override SyntaxNode AssignmentLeft(SyntaxNode assignment) =>
Cast<AssignmentExpressionSyntax>(assignment).Left;
public override SyntaxNode AssignmentRight(SyntaxNode assignment) =>
Cast<AssignmentExpressionSyntax>(assignment).Right;
public override SyntaxNode BinaryExpressionLeft(SyntaxNode binaryExpression) =>
Cast<BinaryExpressionSyntax>(binaryExpression).Left;
public override SyntaxNode BinaryExpressionRight(SyntaxNode binaryExpression) =>
Cast<BinaryExpressionSyntax>(binaryExpression).Right;
public override IEnumerable<SyntaxNode> EnumMembers(SyntaxNode @enum) =>
@enum == null ? Enumerable.Empty<SyntaxNode>() : Cast<EnumDeclarationSyntax>(@enum).Members;
public override SyntaxToken? InvocationIdentifier(SyntaxNode invocation) =>
invocation == null ? null : Cast<InvocationExpressionSyntax>(invocation).GetMethodCallIdentifier();
public override ImmutableArray<SyntaxToken> LocalDeclarationIdentifiers(SyntaxNode node) =>
Cast<LocalDeclarationStatementSyntax>(node).Declaration.Variables.Select(x => x.Identifier).ToImmutableArray();
public override ImmutableArray<SyntaxToken> FieldDeclarationIdentifiers(SyntaxNode node) =>
Cast<FieldDeclarationSyntax>(node).Declaration.Variables.Select(x => x.Identifier).ToImmutableArray();
public override SyntaxKind[] ModifierKinds(SyntaxNode node) =>
node is TypeDeclarationSyntax typeDeclaration
? typeDeclaration.Modifiers.Select(x => x.Kind()).ToArray()
: Array.Empty<SyntaxKind>();
public override SyntaxNode NodeExpression(SyntaxNode node) =>
node switch
{
ArrowExpressionClauseSyntax x => x.Expression,
AttributeArgumentSyntax x => x.Expression,
InterpolationSyntax x => x.Expression,
InvocationExpressionSyntax x => x.Expression,
LockStatementSyntax x => x.Expression,
ReturnStatementSyntax x => x.Expression,
null => null,
_ => throw InvalidOperation(node, nameof(NodeExpression))
};
public override SyntaxToken? NodeIdentifier(SyntaxNode node) =>
node.NodeIdentifier();
public override SyntaxNode RemoveConditionalAccess(SyntaxNode node) =>
node is ExpressionSyntax expression
? expression.RemoveConditionalAccess()
: node;
public override SyntaxNode RemoveParentheses(SyntaxNode node) =>
node.RemoveParentheses();
public override string StringValue(SyntaxNode node, SemanticModel semanticModel) =>
CSharpSyntaxHelper.StringValue(node, semanticModel);
public override bool TryGetInterpolatedTextValue(SyntaxNode node, SemanticModel semanticModel, out string interpolatedValue) =>
Cast<InterpolatedStringExpressionSyntax>(node).TryGetInterpolatedTextValue(semanticModel, out interpolatedValue);
public override bool IsStatic(SyntaxNode node) =>
Cast<BaseMethodDeclarationSyntax>(node).IsStatic();
}