private static int GetNumberOfCrossReferences(AnalyzerLanguage language)
{
return RuleDetailBuilder.GetParameterlessRuleDetails(language)
.Select(rule => rule.Description)
.Select(description => Regex.Matches(description, RuleImplementationMeta.CrosslinkPattern).Count)
.Sum();
}
public IEnumerable<Type> GetParameterlessAnalyzerTypes(AnalyzerLanguage language)
{
return diagnosticAnalyzers
.Where(analyzerType =>
!analyzerType.GetProperties()
.Any(p => p.GetCustomAttributes<RuleParameterAttribute>().Any()))
.Where(type => GetTargetLanguages(type).IsAlso(language));
}
public static Solution GetSolutionWithEmptyFile(AnalyzerLanguage language)
{
using (var workspace = new AdhocWorkspace())
{
var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic;
return workspace.CurrentSolution.AddProject("foo", "foo.dll", lang)
.AddMetadataReference(SystemMetadataReference)
.AddDocument($"foo.{language.GetFileExtension()}", string.Empty)
.Project
.Solution;
}
}
private static void WriteQualityProfileFile(string filePath, IEnumerable<RuleDetail> ruleDetails, AnalyzerLanguage language)
{
var root = new QualityProfileRoot(language);
root.Rules.AddRange(ruleDetails
.Where(descriptor => descriptor.IsActivatedByDefault)
.Select(descriptor => new QualityProfileRuleDescriptor(language)
{
Key = descriptor.Key
}));
SerializeObjectToFile(filePath, root);
}
private static void CheckRuleDescriptorsNotEmpty(AnalyzerLanguage language)
{
var ruleDetails = RuleDetailBuilder.GetAllRuleDetails(language).ToList();
foreach (var ruleDetail in ruleDetails)
{
Assert.IsNotNull(ruleDetail);
Assert.IsNotNull(ruleDetail.Description);
Assert.IsNotNull(ruleDetail.Key);
Assert.IsNotNull(ruleDetail.Title);
}
Assert.AreEqual(ruleDetails.Count,
ruleDetails.Select(descriptor => descriptor.Key).Distinct().Count());
}
public static RuleImplementationMeta Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language)
{
return new RuleImplementationMeta
{
Id = detail.Key,
Language = language.GetFriendlyName(),
Severity = detail.Severity,
Title = detail.Title,
Description = GetParameterDescription(detail.Parameters) +
AddLinksBetweenRulesToDescription(detail.Description, productVersion) +
GetCodeFixDescription(detail),
Tags = detail.Tags
};
}
public bool IsAlso(AnalyzerLanguage other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
if (other == None)
{
throw new NotSupportedException("IsAlso doesn't support AnalyzerLanguage.None.");
}
return this == other || this == Both;
}
public static Solution GetSolutionFromFiles(string filePath, AnalyzerLanguage language)
{
using (var workspace = new AdhocWorkspace())
{
var file = new FileInfo(filePath);
var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic;
var project = workspace.CurrentSolution.AddProject("foo", "foo.dll", lang)
.AddMetadataReference(SystemMetadataReference);
var document = project.AddDocument(file.Name, File.ReadAllText(file.FullName, Encoding.UTF8));
project = document.Project;
return project.Solution;
}
}
public AnalyzerLanguage AddLanguage(AnalyzerLanguage other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
if (this == None ||
this == other)
{
return other;
}
return Both;
}
public Configuration(string path, AnalyzerLanguage language)
{
if (!ParameterLoader.ConfigurationFilePathMatchesExpected(path))
{
throw new ArgumentException(
$"Input configuration doesn't match expected file name: '{ParameterLoader.ParameterConfigurationFileName}'",
nameof(path));
}
Path = path;
analyzers = ImmutableArray.Create(GetAnalyzers(language).ToArray());
var xml = XDocument.Load(path);
var settings = ParseSettings(xml);
IgnoreHeaderComments = "true".Equals(settings[$"sonar.{language}.ignoreHeaderComments"], StringComparison.OrdinalIgnoreCase);
Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList();
AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet();
}
private static RuleDetail GetRuleDetail(Type analyzerType, AnalyzerLanguage language)
{
var rule = analyzerType.GetCustomAttributes<RuleAttribute>().Single();
var ruleDetail = new RuleDetail
{
Key = rule.Key,
Title = rule.Title,
Severity = rule.Severity.ToString(),
IsActivatedByDefault = rule.IsActivatedByDefault,
Description = GetResourceHtml(rule, language)
};
GetParameters(analyzerType, ruleDetail);
GetTags(analyzerType, ruleDetail);
GetSqale(analyzerType, ruleDetail);
GetCodeFixNames(analyzerType, ruleDetail);
return ruleDetail;
}
public static RuleDescription Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language)
{
return new RuleDescription
{
Key = detail.Key,
Data = new Dictionary<string, RuleMetaData>
{
{
language.ToString(),
new RuleMetaData
{
Title = detail.Title,
Description =
GetParameterDescription(detail.Parameters) +
AddLinksBetweenRulesToDescription(detail.Description, productVersion) +
GetCodeFixDescription(detail),
Tags = detail.Tags,
Severity = detail.Severity,
IdeSeverity = detail.IdeSeverity
}
}
}
};
}
public Configuration(XContainer xml, AnalyzerLanguage language)
{
this.language = language;
nonTemplateAnalyzers = ImmutableArray.Create(GetNonTemplateAnalyzers(language).ToArray());
var settings = ParseSettings(xml);
IgnoreHeaderComments = "true".Equals(settings["sonar.cs.ignoreHeaderComments"]);
Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList();
AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet();
var builder = ImmutableList.CreateBuilder<RuleParameterValues>();
foreach (var rule in xml.Descendants("Rule").Where(e => e.Elements("Parameters").Any()))
{
var analyzerId = rule.Elements("Key").Single().Value;
var parameterValues = rule
.Elements("Parameters").Single()
.Elements("Parameter")
.Select(e => new RuleParameterValue
{
ParameterKey = e.Elements("Key").Single().Value,
ParameterValue = e.Elements("Value").Single().Value
});
var pvs = new RuleParameterValues
{
RuleId = analyzerId
};
pvs.ParameterValues.AddRange(parameterValues);
builder.Add(pvs);
}
parameters = builder.ToImmutable();
}
private static int Lines(AnalyzerLanguage language, string text) => MetricsFor(language, text).LineCount;
private static Distribution FunctionComplexityDistribution(AnalyzerLanguage language, string text) =>
MetricsFor(language, text).FunctionComplexityDistribution;
private static int Classes(AnalyzerLanguage language, string text) => MetricsFor(language, text).ClassCount;
private static IImmutableSet<int> LinesOfCode(AnalyzerLanguage language, string text)
{
return MetricsFor(language, text).GetLinesOfCode();
}
private static int Lines(AnalyzerLanguage language, string text)
{
return MetricsFor(language, text).GetLineCount();
}
private static FileComments CommentsWithHeaders(AnalyzerLanguage language, string text)
{
return MetricsFor(language, text).GetComments(false);
}
private static int Statements(AnalyzerLanguage language, string text) => MetricsFor(language, text).StatementCount;
private static int Accessors(AnalyzerLanguage language, string text) => MetricsFor(language, text).AccessorCount;
private static int PublicUndocumentedApi(AnalyzerLanguage language, string text) => MetricsFor(language, text).PublicUndocumentedApiCount;
private static int Functions(AnalyzerLanguage language, string text) => MetricsFor(language, text).FunctionCount;
private static string GetResourceHtml(Type analyzerType, RuleAttribute rule, AnalyzerLanguage language)
{
var resources = SonarLintExtraAssembly.GetManifestResourceNames();
var resource = GetResource(resources, rule.Key, language);
if (resource == null)
{
throw new InvalidDataException(string.Format("Could not locate resource for rule {0}", rule.Key));
}
using (var stream = SonarLintExtraAssembly.GetManifestResourceStream(resource))
using (var reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
}
private static int Complexity(AnalyzerLanguage language, string text) => MetricsFor(language, text).Complexity;
private static string GetResource(IEnumerable<string> resources, string key, AnalyzerLanguage language)
{
if (language == AnalyzerLanguage.CSharp)
{
return resources.FirstOrDefault(r =>
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key), StringComparison.OrdinalIgnoreCase) ||
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key + "_cs"), StringComparison.OrdinalIgnoreCase));
}
if (language == AnalyzerLanguage.VisualBasic)
{
return resources.FirstOrDefault(r =>
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key), StringComparison.OrdinalIgnoreCase) ||
r.EndsWith(string.Format(CultureInfo.InvariantCulture, RuleDescriptionPathPattern, key + "_vb"), StringComparison.OrdinalIgnoreCase));
}
throw new ArgumentException(nameof(language));
}
private static MetricsBase MetricsFor(AnalyzerLanguage language, string text)
{
if (language != AnalyzerLanguage.CSharp &&
language != AnalyzerLanguage.VisualBasic)
{
throw new ArgumentException("Supplied language is not C# neither VB.Net", nameof(language));
}
return language == AnalyzerLanguage.CSharp
? (MetricsBase)new SonarLint.Common.CSharp.Metrics(CSharpSyntaxTree.ParseText(text))
: new SonarLint.Common.VisualBasic.Metrics(VisualBasicSyntaxTree.ParseText(text));
}
public static IEnumerable<RuleDetail> GetParameterlessRuleDetails(AnalyzerLanguage language)
{
return new RuleFinder().GetParameterlessAnalyzerTypes(language).Select(t => GetRuleDetail(t, language));
}
private static IImmutableSet<int> LinesOfCode(AnalyzerLanguage language, string text) => MetricsFor(language, text).LinesOfCode;
public static IEnumerable<DiagnosticAnalyzer> GetAnalyzers(AnalyzerLanguage language)
{
return
new RuleFinder().GetAnalyzerTypes(language)
.Select(type => (DiagnosticAnalyzer) Activator.CreateInstance(type));
}
