public DiagnosticDescription(
object code,
bool isWarningAsError,
string squiggledText,
object[] arguments,
LinePosition?startLocation,
Func <SyntaxNode, bool> syntaxNodePredicate,
bool argumentOrderDoesNotMatter,
Type errorCodeType = null,
DiagnosticSeverity?defaultSeverityOpt = null,
DiagnosticSeverity?effectiveSeverityOpt = null,
bool isSuppressed = false)
{
_code = code;
_isWarningAsError = isWarningAsError;
_squiggledText = squiggledText;
_arguments = arguments;
_startPosition = startLocation;
_syntaxPredicate = syntaxNodePredicate;
_argumentOrderDoesNotMatter = argumentOrderDoesNotMatter;
_errorCodeType = errorCodeType ?? code.GetType();
_defaultSeverityOpt = defaultSeverityOpt;
_effectiveSeverityOpt = effectiveSeverityOpt;
_isSuppressed = isSuppressed;
}
private static void AnalyzeAnalyzerReleases(
string ruleId,
IArgumentOperation ruleIdArgument,
string?category,
string analyzerName,
string?helpLink,
bool?isEnabledByDefault,
DiagnosticSeverity?defaultSeverity,
ReleaseTrackingData shippedData,
ReleaseTrackingData unshippedData,
Action <Diagnostic> addDiagnostic)
{
if (!TryGetLatestReleaseTrackingLine(ruleId, shippedData, unshippedData, out _, out var releaseTrackingLine) ||
releaseTrackingLine.IsShipped && releaseTrackingLine.IsRemovedRule)
{
var properties = ImmutableDictionary <string, string?> .Empty.Add(
EntryToAddPropertyName, GetEntry(ruleId, category, analyzerName, helpLink, isEnabledByDefault, defaultSeverity));
var diagnostic = ruleIdArgument.CreateDiagnostic(DeclareDiagnosticIdInAnalyzerReleaseRule, properties, ruleId);
addDiagnostic(diagnostic);
return;
}
if (releaseTrackingLine.IsRemovedRule)
{
var diagnostic = ruleIdArgument.CreateDiagnostic(UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdRule, ruleId);
addDiagnostic(diagnostic);
return;
}
if (category != null && !string.Equals(category, releaseTrackingLine.Category, StringComparison.OrdinalIgnoreCase) ||
isEnabledByDefault != null && isEnabledByDefault != releaseTrackingLine.EnabledByDefault ||
defaultSeverity != null && defaultSeverity != releaseTrackingLine.DefaultSeverity)
{
string propertyName;
(string category, bool?isEnabledByDefault, DiagnosticSeverity? defaultSeverity)? oldRule = null;
if (!releaseTrackingLine.IsShipped)
{
// For existing entry in unshipped file, we can just update.
propertyName = EntryToUpdatePropertyName;
if (releaseTrackingLine is ChangedRuleReleaseTrackingLine changedLine)
{
oldRule = (changedLine.OldCategory, changedLine.OldEnabledByDefault, changedLine.OldDefaultSeverity);
}
}
else
{
// Need to add a new changed rule entry in unshipped file.
propertyName = EntryToAddPropertyName;
oldRule = (releaseTrackingLine.Category, releaseTrackingLine.EnabledByDefault, releaseTrackingLine.DefaultSeverity);
}
var newEntry = GetEntry(ruleId, category, analyzerName, helpLink, isEnabledByDefault, defaultSeverity, oldRule);
var properties = ImmutableDictionary <string, string?> .Empty.Add(propertyName, newEntry);
var diagnostic = ruleIdArgument.CreateDiagnostic(UpdateDiagnosticIdInAnalyzerReleaseRule, properties, ruleId);
addDiagnostic(diagnostic);
return;
}
}
private static string GetEntry(
string ruleId,
string?category,
string analyzerName,
string?helpLink,
bool?isEnabledByDefault,
DiagnosticSeverity?defaultSeverity,
(string category, bool?isEnabledByDefault, DiagnosticSeverity? defaultSeverity)?oldRule = null)
internal NewOrRemovedRuleReleaseTrackingLine(
string ruleId, string category, bool?enabledByDefault,
DiagnosticSeverity?defaultSeverity,
TextSpan span, SourceText sourceText,
string path, bool isShipped, ReleaseTrackingRuleEntryKind kind)
: base(ruleId, category, enabledByDefault, defaultSeverity, span, sourceText, path, isShipped, kind)
{
Debug.Assert(kind == ReleaseTrackingRuleEntryKind.New || kind == ReleaseTrackingRuleEntryKind.Removed);
}
internal static ReleaseTrackingLine Create(
string ruleId, string category, bool?enabledByDefault,
DiagnosticSeverity?defaultSeverity,
TextSpan span, SourceText sourceText,
string path, bool isShipped, ReleaseTrackingRuleEntryKind kind)
{
return(new NewOrRemovedRuleReleaseTrackingLine(ruleId, category,
enabledByDefault, defaultSeverity, span, sourceText, path, isShipped, kind));
}
internal ChangedRuleReleaseTrackingLine(
string ruleId, string category, bool?enabledByDefault,
DiagnosticSeverity?defaultSeverity,
string oldCategory, bool?oldEnabledByDefault,
DiagnosticSeverity?oldDefaultSeverity,
TextSpan span, SourceText sourceText,
string path, bool isShipped)
: base(ruleId, category, enabledByDefault, defaultSeverity, span, sourceText, path, isShipped, ReleaseTrackingRuleEntryKind.Changed)
{
OldCategory = oldCategory;
OldEnabledByDefault = oldEnabledByDefault;
OldDefaultSeverity = oldDefaultSeverity;
}
public static DiagnosticSeverity?GetWorst(this DiagnosticSeverity?value1, DiagnosticSeverity?value2)
{
if (value1 == null)
{
return(value2);
}
if (value2 == null)
{
return(value1);
}
return(GetWorst(value1.Value, value2.Value));
}
private static void AnalyzeRuleId(
OperationAnalysisContext operationAnalysisContext,
ImmutableArray <IArgumentOperation> creationArguments,
bool isAnalyzerReleaseTracking,
ReleaseTrackingData?shippedData,
ReleaseTrackingData?unshippedData,
PooledConcurrentSet <string> seenRuleIds,
AdditionalText?diagnosticCategoryAndIdRangeTextOpt,
string?category,
string analyzerName,
string?helpLink,
bool?isEnabledByDefault,
DiagnosticSeverity?defaultSeverity,
ImmutableArray <(string?prefix, int start, int end)> allowedIdsInfoListOpt,
static ImageMoniker GetImageMoniker(DiagnosticSeverity?severity)
{
switch (severity)
{
default:
case DiagnosticSeverity.Suggestion:
return(ImageMonikers.AnalysisOK);
case DiagnosticSeverity.Warning:
return(ImageMonikers.AnalysisWarning);
case DiagnosticSeverity.Error:
return(ImageMonikers.AnalysisError);
}
}
protected ReleaseTrackingLine(string ruleId, string category, bool?enabledByDefault,
DiagnosticSeverity?defaultSeverity,
TextSpan span, SourceText sourceText,
string path, bool isShipped, ReleaseTrackingRuleEntryKind kind)
{
RuleId = ruleId;
Category = category;
EnabledByDefault = enabledByDefault;
DefaultSeverity = defaultSeverity;
Span = span;
SourceText = sourceText;
Path = path;
IsShipped = isShipped;
Kind = kind;
}
public static DiagnosticSeverity?GetWorst(this IEnumerable <DiagnosticSeverity> values)
{
DiagnosticSeverity?worst = null;
foreach (var v in values)
{
// Shortcut: Error
if (v == DiagnosticSeverity.Error)
{
return(DiagnosticSeverity.Error);
}
worst = worst.GetWorst(v);
}
return(worst);
}
public static DiagnosticSeverity?GetConfigurationValue(this AnalyzerOptions options, string filePath, string key, DiagnosticSeverity?defaultValue)
{
var configuration = GetConfigurationHierarchy(options);
if (configuration.TryGetValue(filePath, key, out var value))
{
if (value != null && Enum.TryParse <DiagnosticSeverity>(value, ignoreCase: true, out var result))
{
return(result);
}
}
return(defaultValue);
}
public ProjectBuilder ShouldReportDiagnostic(int line, int column, string id = null, string message = null, DiagnosticSeverity?severity = null)
{
return(ShouldReportDiagnostic(new DiagnosticResult
{
Id = id ?? DefaultAnalyzerId,
Message = message ?? DefaultAnalyzerMessage,
Severity = severity,
Locations = new[]
{
new DiagnosticResultLocation(FileName ?? "Test0.cs", line, column),
},
}));
}
private static (bool?isEnabledByDefault, DiagnosticSeverity?defaultSeverity) GetDefaultSeverityAndEnabledByDefault(Compilation compilation, ImmutableArray <IArgumentOperation> creationArguments)
{
var diagnosticSeverityType = compilation.GetOrCreateTypeByMetadataName(typeof(DiagnosticSeverity).FullName);
var ruleLevelType = compilation.GetOrCreateTypeByMetadataName(typeof(RuleLevel).FullName);
bool?isEnabledByDefault = null;
DiagnosticSeverity?defaultSeverity = null;
foreach (var argument in creationArguments)
{
switch (argument.Parameter.Name)
{
case IsEnabledByDefaultParameterName:
if (argument.Value.ConstantValue.HasValue)
{
isEnabledByDefault = (bool)argument.Value.ConstantValue.Value;
}
break;
case DefaultSeverityParameterName:
if (argument.Value is IFieldReferenceOperation fieldReference &&
fieldReference.Field.ContainingType.Equals(diagnosticSeverityType) &&
Enum.TryParse(fieldReference.Field.Name, out DiagnosticSeverity parsedSeverity))
{
defaultSeverity = parsedSeverity;
}
break;
case RuleLevelParameterName:
if (ruleLevelType != null &&
argument.Value is IFieldReferenceOperation fieldReference2 &&
fieldReference2.Field.ContainingType.Equals(ruleLevelType) &&
Enum.TryParse(fieldReference2.Field.Name, out RuleLevel parsedRuleLevel))
{
switch (parsedRuleLevel)
{
case RuleLevel.BuildWarning:
defaultSeverity = DiagnosticSeverity.Warning;
isEnabledByDefault = true;
break;
case RuleLevel.IdeSuggestion:
defaultSeverity = DiagnosticSeverity.Info;
isEnabledByDefault = true;
break;
case RuleLevel.IdeHidden_BulkConfigurable:
defaultSeverity = DiagnosticSeverity.Hidden;
isEnabledByDefault = true;
break;
case RuleLevel.Disabled:
case RuleLevel.CandidateForRemoval:
isEnabledByDefault = false;
break;
}
return(isEnabledByDefault, defaultSeverity);
}
break;
}
}
if (isEnabledByDefault == false)
{
defaultSeverity = null;
}
return(isEnabledByDefault, defaultSeverity);
}
public DiagnosticDescription(Diagnostic d, bool errorCodeOnly, bool includeDefaultSeverity = false, bool includeEffectiveSeverity = false)
{
_code = d.Code;
_isWarningAsError = d.IsWarningAsError;
_location = d.Location;
_defaultSeverityOpt = includeDefaultSeverity ? d.DefaultSeverity : (DiagnosticSeverity?)null;
_effectiveSeverityOpt = includeEffectiveSeverity ? d.Severity : (DiagnosticSeverity?)null;
DiagnosticWithInfo dinfo = null;
if (d.Code == 0)
{
_code = d.Id;
_errorCodeType = typeof(string);
}
else
{
dinfo = d as DiagnosticWithInfo;
if (dinfo == null)
{
_code = d.Code;
_errorCodeType = typeof(int);
}
else
{
_errorCodeType = dinfo.Info.MessageProvider.ErrorCodeType;
_code = d.Code;
}
}
_ignoreArgumentsWhenComparing = errorCodeOnly;
if (!_ignoreArgumentsWhenComparing)
{
if (_location.IsInSource)
{
// we don't just want to do SyntaxNode.GetText(), because getting the text via the SourceTree validates the public API
_squiggledText = _location.SourceTree.GetText().ToString(_location.SourceSpan);
}
if (dinfo != null)
{
_arguments = dinfo.Info.Arguments;
}
else
{
var args = d.Arguments;
if (args == null || args.Count == 0)
{
_arguments = null;
}
else
{
_arguments = d.Arguments.ToArray();
}
}
if (_arguments != null && _arguments.Length == 0)
{
_arguments = null;
}
}
_startPosition = _location.GetMappedLineSpan().StartLinePosition;
}
void UpdateDiagnostics() {
var mappingSpan = _textView.BufferGraph.CreateMappingSpan(
new SnapshotSpan(_textView.TextSnapshot, 0, _textView.TextSnapshot.Length),
SpanTrackingMode.EdgeInclusive);
var diagnosticMapping = _errorTagAggregator.GetTags(mappingSpan)
.GroupBy(tagSpan => tagSpan.Tag.Diagnostic.Severity)
.ToDictionary(
grouping => grouping.Key,
grouping => grouping.OrderBy(tags => tags.Tag.Diagnostic.Location.Start)
.ToList()
.AsReadOnly());
_diagnosticMapping = diagnosticMapping;
_worstSeverity = diagnosticMapping.Keys.GetWorst();
OnDiagnosticsChanged();
}
private static bool IsSuppressableSeverity(DiagnosticSeverity?diagnosticSeverity) => diagnosticSeverity == DiagnosticSeverity.Error || diagnosticSeverity == DiagnosticSeverity.Warning;