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);
}
}
protected override void OnTestMethod(SyntaxNodeAnalysisContext context, MethodDeclarationSyntax methodDeclaration, bool isDataTestMethod)
{
SyntaxList <AttributeListSyntax> attributeLists = methodDeclaration.AttributeLists;
Location categoryLocation;
ClassDeclarationSyntax classDeclaration = methodDeclaration.Parent as ClassDeclarationSyntax;
if (classDeclaration != null)
{
var exceptions = AdditionalFilesHelper.LoadExceptions(FileName);
if (exceptions.Contains($"{classDeclaration.Identifier.Text}.{methodDeclaration.Identifier.Text}"))
{
return;
}
}
if (Helper.HasAttribute(attributeLists, context, MsTestFrameworkDefinitions.TestCategoryAttribute, out categoryLocation, out string category))
{
List <string> allowedCategories = AdditionalFilesHelper.GetValuesFromEditorConfig(Rule.Id, @"allowed_test_categories");
if (!allowedCategories.Contains(category.Replace("\"", string.Empty)))
{
Diagnostic diagnostic = Diagnostic.Create(Rule, categoryLocation);
context.ReportDiagnostic(diagnostic);
}
}
else
{
Diagnostic diagnostic = Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation());
context.ReportDiagnostic(diagnostic);
}
}
protected override void OnInitializeAnalyzer(AnalyzerOptions options, Compilation compilation)
{
AdditionalFilesHelper helper = new AdditionalFilesHelper(options, compilation);
_exceptions = helper.LoadExceptions(FileName);
_allowedCategories = helper.GetValuesFromEditorConfig(Rule.Id, @"allowed_test_categories");
}
/// <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);
});
}
protected override TestMethodImplementation OnInitializeTestMethodAnalyzer(AnalyzerOptions options, Compilation compilation, MsTestAttributeDefinitions definitions)
{
AdditionalFilesHelper helper = new AdditionalFilesHelper(options, compilation);
var exceptions = helper.LoadExceptions(FileName);
var allowedCategories = helper.GetValuesFromEditorConfig(Rule.Id, @"allowed_test_categories").ToImmutableHashSet();
return(new TestHasCategoryAttribute(exceptions, allowedCategories, definitions));
}
public virtual void Register(CompilationStartAnalysisContext compilationContext)
{
AdditionalFilesHelper helper = new AdditionalFilesHelper(compilationContext.Options, compilationContext.Compilation);
HashSet <string> exceptions = helper.InitializeExceptions(FileName, Rule.Id);
// Add standard exceptions
exceptions.Add(@"*.Startup");
exceptions.Add(@"*.Program");
exceptions.Add(@"*.AssemblyInitialize");
var compilationAnalyzer = CreateCompilationAnalyzer(exceptions, helper.ExceptionsOptions.GenerateExceptionsFile);
compilationContext.RegisterSyntaxNodeAction(compilationAnalyzer.Analyze, SyntaxKind.ClassDeclaration);
}
public override void Initialize(AnalysisContext context)
{
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
context.EnableConcurrentExecution();
context.RegisterCompilationStartAction(startContext =>
{
if (startContext.Compilation.GetTypeByMetadataName("Microsoft.VisualStudio.TestTools.UnitTesting.Assert") == null)
{
return;
}
AdditionalFilesHelper = new AdditionalFilesHelper(startContext.Options.AdditionalFiles);
startContext.RegisterSyntaxNodeAction(Analyze, SyntaxKind.MethodDeclaration);
});
}
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);
}
/// <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 methodNames = additionalFiles.GetValuesFromEditorConfig(Rule.Id, LogMethodNames);
var compilationAnalyzer = new CompilationAnalyzer(methodNames);
if (methodNames.Count == 0)
{
startContext.RegisterCompilationEndAction(compilationAnalyzer.ReportParsingError);
}
else
{
startContext.RegisterSyntaxNodeAction(compilationAnalyzer.AnalyzeCatchException, SyntaxKind.CatchClause);
}
});
}
public TestHasTimeout(MsTestAttributeDefinitions definitions, AdditionalFilesHelper additionalFilesHelper) : base(definitions)
{
_additionalFilesHelper = additionalFilesHelper;
}
protected override TestMethodImplementation OnInitializeTestMethodAnalyzer(AnalyzerOptions options, Compilation compilation, MsTestAttributeDefinitions definitions)
{
var additionalFilesHelper = new AdditionalFilesHelper(options, compilation);
return(new TestHasTimeout(definitions, additionalFilesHelper));
}
