/
AnalyzerExtensions.cs
81 lines (71 loc) · 3.4 KB
/
AnalyzerExtensions.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
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using System;
using System.Linq;
namespace CodeCracker
{
public static class AnalyzerExtensions
{
public static void RegisterSyntaxNodeAction<TLanguageKindEnum>(this AnalysisContext context, LanguageVersion languageVersion, Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct
{
context.RegisterCompilationStartAction(languageVersion, compilationContext => compilationContext.RegisterSyntaxNodeAction(action, syntaxKinds));
}
public static void RegisterCompilationStartAction(this AnalysisContext context, LanguageVersion languageVersion, Action<CompilationStartAnalysisContext> registrationAction)
{
context.RegisterCompilationStartAction(compilationContext => compilationContext.RunIfCSharp6OrGreater(() => registrationAction?.Invoke(compilationContext)));
}
private static void RunIfCSharp6OrGreater(this CompilationStartAnalysisContext context, Action action)
{
context.Compilation.RunIfCSharp6OrGreater(action);
}
private static void RunIfCSharp6OrGreater(this Compilation compilation, Action action)
{
var cSharpCompilation = compilation as CSharpCompilation;
if (cSharpCompilation == null) return;
cSharpCompilation.LanguageVersion.RunIfCSharp6OrGreater(action);
}
private static void RunIfCSharp6OrGreater(this LanguageVersion languageVersion, Action action)
{
if (languageVersion >= LanguageVersion.CSharp6) action?.Invoke();
}
public static ConditionalAccessExpressionSyntax ToConditionalAccessExpression(this MemberAccessExpressionSyntax memberAccess)
{
return SyntaxFactory.ConditionalAccessExpression(memberAccess.Expression, SyntaxFactory.MemberBindingExpression(memberAccess.Name));
}
public static StatementSyntax GetSingleStatementFromPossibleBlock(this StatementSyntax statement)
{
var block = statement as BlockSyntax;
if (block != null)
{
if (block.Statements.Count != 1) return null;
return block.Statements.Single();
}
else
{
return statement;
}
}
public static SyntaxNode WithSameTriviaAs(this SyntaxNode target, SyntaxNode source)
{
if (target == null) throw new ArgumentNullException(nameof(target));
if (source == null) throw new ArgumentNullException(nameof(source));
return target
.WithLeadingTrivia(source.GetLeadingTrivia())
.WithTrailingTrivia(source.GetTrailingTrivia());
}
public static bool IsEmbeddedStatementOwner(this SyntaxNode node)
{
return node is IfStatementSyntax ||
node is ElseClauseSyntax ||
node is ForStatementSyntax ||
node is ForEachStatementSyntax ||
node is WhileStatementSyntax ||
node is UsingStatementSyntax ||
node is DoStatementSyntax ||
node is LockStatementSyntax ||
node is FixedStatementSyntax;
}
}
}