private static void Analyze(CompilationAnalysisContext context)
{
Version expectedVersion = new Version(@"1.0.0.0");
var additionalFilesHelper = new AdditionalFilesHelper(context.Options, context.Compilation);
string value = additionalFilesHelper.GetValueFromEditorConfig(Rule.Id, @"assembly_version");
if (!string.IsNullOrWhiteSpace(value))
{
bool isParseSuccessful = Version.TryParse(value.ToString(), out Version parsedVersion);
if (!isParseSuccessful)
{
Diagnostic diagnostic = Diagnostic.Create(InvalidExpectedVersionRule, null, value);
context.ReportDiagnostic(diagnostic);
return;
}
expectedVersion = parsedVersion;
}
Version actualVersion = context.Compilation.Assembly.Identity.Version;
if (actualVersion.CompareTo(expectedVersion) != 0)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, null, actualVersion.ToString(), expectedVersion.ToString());
context.ReportDiagnostic(diagnostic);
}
}
/// <summary>
/// <inheritdoc/>
/// </summary>
public override void Initialize(AnalysisContext context)
{
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.EnableConcurrentExecution();
context.RegisterCompilationStartAction(
startContext =>
{
var additionalFiles = new AdditionalFilesHelper(
startContext.Options,
startContext.Compilation);
var maxStr = additionalFiles.GetValueFromEditorConfig(Rule.Id, "max_operators");
if (int.TryParse(maxStr, out int parsedMax))
{
_maxOperators = parsedMax;
}
else
{
_maxOperators = DefaultMaxOperators;
}
startContext.RegisterSyntaxNodeAction(
AnalyzeIfStatement,
SyntaxKind.IfStatement);
startContext.RegisterSyntaxNodeAction(
AnalyzeTernary,
SyntaxKind.ConditionalExpression);
});
}
private static bool CheckCopyrightStatement(SyntaxNodeAnalysisContext context, SyntaxTrivia trivia)
{
var comment = trivia.ToFullString();
// Check the copyright mar itself
var hasCopyright = comment.Contains("©") || comment.Contains("Copyright");
// Check the year
bool hasYear = yearRegex.IsMatch(comment);
// Check the company name, only if it is configured.
var additionalFilesHelper = new AdditionalFilesHelper(context.Options, context.Compilation);
var companyName = additionalFilesHelper.GetValueFromEditorConfig(Rule.Id, @"company_name");
var hasCompanyName = string.IsNullOrEmpty(companyName) || comment.Contains(companyName);
return(hasCopyright && hasYear && hasCompanyName);
}
private void Analyze(SyntaxNodeAnalysisContext context)
{
AdditionalFilesHelper additionalFilesHelper = new AdditionalFilesHelper(context.Options, context.Compilation);
string expected_prefix = additionalFilesHelper.GetValueFromEditorConfig(RuleForIncorrectNamespace.Id, @"namespace_prefix");
NamespaceDeclarationSyntax namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
string myNamespace = namespaceDeclaration.Name.ToString();
if (string.IsNullOrEmpty(expected_prefix))
{
Diagnostic diagnostic = Diagnostic.Create(RuleForEmptyPrefix, namespaceDeclaration.Name.GetLocation());
context.ReportDiagnostic(diagnostic);
}
else if (!myNamespace.StartsWith(expected_prefix))
{
Diagnostic diagnostic = Diagnostic.Create(RuleForIncorrectNamespace, namespaceDeclaration.Name.GetLocation());
context.ReportDiagnostic(diagnostic);
}
}
public virtual EditorConfigOptions InitializeEditorConfigOptions(AnalyzerOptions analyzerOptions, Compilation compilation, out Diagnostic error)
{
error = null;
EditorConfigOptions options = new EditorConfigOptions(DefaultDuplicateTokenThreshold);
var editorConfigHelper = new AdditionalFilesHelper(analyzerOptions, compilation);
ExceptionsOptions exceptionsOptions = editorConfigHelper.LoadExceptionsOptions(Rule.Id);
options.IgnoreExceptionsFile = exceptionsOptions.IgnoreExceptionsFile;
options.GenerateExceptionsFile = exceptionsOptions.GenerateExceptionsFile;
string strTokenCount = editorConfigHelper.GetValueFromEditorConfig(Rule.Id, @"token_count");
if (!string.IsNullOrWhiteSpace(strTokenCount))
{
strTokenCount = strTokenCount.Trim();
bool isParseSuccessful = int.TryParse(strTokenCount, out int duplicateTokenThreshold);
if (!isParseSuccessful)
{
duplicateTokenThreshold = DefaultDuplicateTokenThreshold;
error = Diagnostic.Create(InvalidTokenCountRule, null, strTokenCount);
}
const int MaxTokenCount = 200;
if (duplicateTokenThreshold > MaxTokenCount)
{
error = Diagnostic.Create(TokenCountTooBigRule, null, duplicateTokenThreshold, MaxTokenCount);
duplicateTokenThreshold = MaxTokenCount;
}
const int MinTokenCount = 20;
if (duplicateTokenThreshold < MinTokenCount)
{
error = Diagnostic.Create(TokenCountTooSmallRule, null, duplicateTokenThreshold, MinTokenCount);
duplicateTokenThreshold = MinTokenCount;
}
options.TokenCount = duplicateTokenThreshold;
}
return(options);
}
