private SimpleDiagnostic( DiagnosticDescriptor descriptor, DiagnosticSeverity severity, int warningLevel, Location location, IEnumerable<Location> additionalLocations, object[] messageArgs) { if ((warningLevel == 0 && severity != DiagnosticSeverity.Error) || (warningLevel != 0 && severity == DiagnosticSeverity.Error)) { throw new ArgumentException(nameof(warningLevel)); } if(descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } _descriptor = descriptor; _severity = severity; _warningLevel = warningLevel; _location = location ?? Location.None; _additionalLocations = additionalLocations == null ? SpecializedCollections.EmptyReadOnlyList<Location>() : additionalLocations.ToImmutableArray(); _messageArgs = messageArgs ?? SpecializedCollections.EmptyArray<object>(); }
public Diagnostic(TextSpan textSpan, DiagnosticId diagnosticId, string message) { Span = textSpan; Message = message; DiagnosticId = diagnosticId; Severity = DiagnosticFacts.GetSeverity(diagnosticId); }
private SimpleDiagnostic( DiagnosticDescriptor descriptor, DiagnosticSeverity severity, int warningLevel, Location location, IEnumerable<Location> additionalLocations, object[] messageArgs, ImmutableDictionary<string, string> properties, bool isSuppressed) { if ((warningLevel == 0 && severity != DiagnosticSeverity.Error) || (warningLevel != 0 && severity == DiagnosticSeverity.Error)) { throw new ArgumentException(nameof(warningLevel)); } if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } _descriptor = descriptor; _severity = severity; _warningLevel = warningLevel; _location = location ?? Location.None; _additionalLocations = additionalLocations?.ToImmutableArray() ?? SpecializedCollections.EmptyReadOnlyList<Location>(); _messageArgs = messageArgs ?? Array.Empty<object>(); _properties = properties ?? ImmutableDictionary<string, string>.Empty; _isSuppressed = isSuppressed; }
public readonly TextSpan TextSpan; //opt #endregion Fields #region Constructors public Diagnostic(DiagnosticSeverity severity, int code, string message, TextSpan textSpan) { Severity = severity; Code = code; Message = message; TextSpan = textSpan; }
internal SimpleDiagnostic(string id, string category, string message, DiagnosticSeverity severity, bool isEnabledByDefault, int warningLevel, bool isWarningAsError, Location location, IEnumerable<Location> additionalLocations) { if (isWarningAsError && severity != DiagnosticSeverity.Warning) { throw new ArgumentException("isWarningAsError"); } if ((warningLevel == 0 && severity == DiagnosticSeverity.Warning) || (warningLevel != 0 && severity != DiagnosticSeverity.Warning)) { throw new ArgumentException("warningLevel"); } this.id = id; this.category = category; this.message = message; this.severity = severity; this.isEnabledByDefault = isEnabledByDefault; this.warningLevel = warningLevel; this.isWarningAsError = isWarningAsError; this.location = location; this.additionalLocations = additionalLocations == null ? SpecializedCollections.EmptyReadOnlyList<Location>() : additionalLocations.ToImmutableArray(); }
/// <summary> /// インスタンスを初期化します。 /// </summary> /// <param name="id">解析したルールの識別子</param> /// <param name="message">解析結果のメッセージ</param> /// <param name="severity">解析したルールの重大度</param> /// <param name="locations">解析結果が示すソースコードの位置</param> public DiagnosticResult(string id, string message, DiagnosticSeverity? severity, params DiagnosticResultLocation[] locations) { Id = id; Message = message; Severity = severity; Locations = locations ?? new DiagnosticResultLocation[0]; }
// Given a message identifier (e.g., CS0219), severity, warning as error and a culture, // get the entire prefix (e.g., "error CS0219: Warning as Error:" for C#) used on error messages. public override string GetMessagePrefix(string id, DiagnosticSeverity severity, bool isWarningAsError, CultureInfo culture) { return String.Format(culture, "{0} {1}{2}", severity == DiagnosticSeverity.Error || isWarningAsError ? "error" : "warning", id, isWarningAsError ? ErrorFacts.GetMessage(MessageID.IDS_WarnAsError, culture) : ""); }
public DiagnosticData( string id, string category, string message, string enuMessageForBingSearch, DiagnosticSeverity severity, bool isEnabledByDefault, int warningLevel, Workspace workspace, ProjectId projectId, DocumentId documentId = null, TextSpan? span = null, string originalFilePath = null, int originalStartLine = 0, int originalStartColumn = 0, int originalEndLine = 0, int originalEndColumn = 0, string title = null, string description = null, string helpLink = null) : this( id, category, message, enuMessageForBingSearch, severity, severity, isEnabledByDefault, warningLevel, ImmutableArray<string>.Empty, ImmutableDictionary<string, string>.Empty, workspace, projectId, documentId, span, null, originalStartLine, originalStartColumn, originalEndLine, originalEndColumn, originalFilePath, originalStartLine, originalStartColumn, originalEndLine, originalEndColumn, title, description, helpLink) { }
public AnalyzerDetails(string className, AnalyzerCategoryDetails category, DefaultState defaultState, DiagnosticSeverity severity, string titleResourceName, string descriptionResourceName, string messageFormatResourceName, IList<Type> suppressionAttributes) { var decomposedDetails = DecomposeDetailsFromClassName(className); var code = decomposedDetails.Item1; Name = decomposedDetails.Item2; NameWithCode = $"{decomposedDetails.Item3} - {Name}"; Category = category; _defaultState = defaultState; Severity = severity; SuppressionAttributes = suppressionAttributes; Title = LocalizableStringFactory.LocalizableResourceString(titleResourceName); Description = LocalizableStringFactory.LocalizableResourceString(descriptionResourceName); MessageFormat = LocalizableStringFactory.LocalizableResourceString(messageFormatResourceName); DiagnosticId = Title.ToString().Replace("-", ""); if (Title.ToString() != code) { throw new ArgumentException($@"Title resource value isn't of the correct format: should be {code}", nameof(titleResourceName)); } }
public EnforcementLevel(DiagnosticSeverity severity) { Value = severity; switch (severity) { case DiagnosticSeverity.Hidden: Name = "None"; Moniker = KnownMonikers.None; return; case DiagnosticSeverity.Info: Name = "Suggestion"; Moniker = KnownMonikers.StatusInformation; return; case DiagnosticSeverity.Warning: Name = "Warning"; Moniker = KnownMonikers.StatusWarning; return; case DiagnosticSeverity.Error: Name = "Error"; Moniker = KnownMonikers.StatusError; return; default: throw new ArgumentException("Unexpected DiagnosticSeverity", nameof(severity)); } }
static void TestParseEditorConfigCodeStyleOption(string args, bool isEnabled, DiagnosticSeverity severity) { var notificationOption = NotificationOption.None; switch (severity) { case DiagnosticSeverity.Hidden: notificationOption = NotificationOption.None; break; case DiagnosticSeverity.Info: notificationOption = NotificationOption.Suggestion; break; case DiagnosticSeverity.Warning: notificationOption = NotificationOption.Warning; break; case DiagnosticSeverity.Error: notificationOption = NotificationOption.Error; break; } var codeStyleOption = new CodeStyleOption<bool>(value: isEnabled, notification: notificationOption); var result = CodeStyleHelpers.ParseEditorConfigCodeStyleOption(args); Assert.True(result.Value == isEnabled, $"Expected {nameof(isEnabled)} to be {isEnabled}, was {result.Value}"); Assert.True(result.Notification.Value == severity, $"Expected {nameof(severity)} to be {severity}, was {result.Notification.Value}"); }
private DiagnosticDescriptor CreateDescriptorWithId(string id, LocalizableString title, LocalizableString message, DiagnosticSeverity severity, params string[] customTags) => new DiagnosticDescriptor( id, title, message, DiagnosticCategory.Style, severity, isEnabledByDefault: true, customTags: customTags);
// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode) { _messageProvider = messageProvider; _errorCode = errorCode; _defaultSeverity = messageProvider.GetSeverity(errorCode); _effectiveSeverity = _defaultSeverity; }
// Take a warning and return the final deposition of the given warning, // based on both command line options and pragmas. // If you update this method, also update DiagnosticItemSource.GetEffectiveSeverity. internal static ReportDiagnostic GetDiagnosticReport(DiagnosticSeverity severity, bool isEnabledByDefault, string id, int diagnosticWarningLevel, Location location, string category, int warningLevelOption, ReportDiagnostic generalDiagnosticOption, IDictionary<string, ReportDiagnostic> specificDiagnosticOptions) { // Read options (e.g., /nowarn or /warnaserror) ReportDiagnostic report = ReportDiagnostic.Default; var isSpecified = specificDiagnosticOptions.TryGetValue(id, out report); if (!isSpecified) { report = isEnabledByDefault ? ReportDiagnostic.Default : ReportDiagnostic.Suppress; } // Compute if the reporting should be suppressed. if (diagnosticWarningLevel > warningLevelOption // honor the warning level || report == ReportDiagnostic.Suppress) // check options (/nowarn) { return ReportDiagnostic.Suppress; } // If location is available, check out pragmas if (location != null && location.SourceTree != null && ((SyntaxTree)location.SourceTree).GetPragmaDirectiveWarningState(id, location.SourceSpan.Start) == ReportDiagnostic.Suppress) { return ReportDiagnostic.Suppress; } // Unless specific warning options are defined (/warnaserror[+|-]:<n> or /nowarn:<n>, // follow the global option (/warnaserror[+|-] or /nowarn). if (report == ReportDiagnostic.Default) { switch (generalDiagnosticOption) { case ReportDiagnostic.Error: // If we've been asked to do warn-as-error then don't raise severity for anything below warning (info or hidden). if (severity == DiagnosticSeverity.Warning) { // In the case where /warnaserror+ is followed by /warnaserror-:<n> on the command line, // do not promote the warning specified in <n> to an error. if (!isSpecified && (report == ReportDiagnostic.Default)) { return ReportDiagnostic.Error; } } break; case ReportDiagnostic.Suppress: // When doing suppress-all-warnings, don't lower severity for anything other than warning and info. // We shouldn't suppress hidden diagnostics here because then features that use hidden diagnostics to // display a lightbulb would stop working if someone has suppress-all-warnings (/nowarn) specified in their project. if (severity == DiagnosticSeverity.Warning || severity == DiagnosticSeverity.Info) { return ReportDiagnostic.Suppress; } break; default: break; } } return report; }
public Result (TextSpan region, string message, DiagnosticSeverity level, IssueMarker inspectionMark, bool underline = true) { this.Region = region; this.Message = message; this.Level = level; this.InspectionMark = inspectionMark; this.Underline = underline; }
/// <summary> /// Create a DiagnosticDescriptor, which provides description about a <see cref="Diagnostic"/>. /// </summary> /// <param name="id">A unique identifier for the diagnostic. For example, code analysis diagnostic ID "CA1001".</param> /// <param name="description">A short localizable description of the diagnostic. For example, for CA1001: "Types that own disposable fields should be disposable".</param> /// <param name="messageFormat">A localizable format message string, which can be passed as the first argument to <see cref="M:System.String.Format"/> when creating the diagnostic message with this descriptor. /// For example, for CA1001: "Implement IDisposable on '{0}' because it creates members of the following IDisposable types: '{1}'."</param> /// <param name="category">The category of the diagnostic (like Design, Naming etc.). For example, for CA1001: "Microsoft.Design".</param> /// <param name="defaultSeverity">Default severity of the diagnostic.</param> public DiagnosticDescriptor(string id, string description, string messageFormat, string category, DiagnosticSeverity defaultSeverity) { this.Id = id; this.Description = description; this.Category = category; this.MessageFormat = messageFormat; this.DefaultSeverity = defaultSeverity; }
private DiagnosticDescriptor CreateDiagnosticDescriptor(DiagnosticSeverity severity) => new DiagnosticDescriptor( _diagnosticId, _title, _message, DiagnosticCategory.Style, severity, isEnabledByDefault: true);
public static CodeAction Create(TextSpan textSpan, DiagnosticSeverity severity, string description, Func<CancellationToken, Task<Solution>> createChangedSolution) { if (description == null) throw new ArgumentNullException(nameof(description)); if (createChangedSolution == null) throw new ArgumentNullException(nameof(createChangedSolution)); return new DocumentChangeAction(textSpan, severity, description, createChangedSolution); }
private static DiagnosticDescriptor CreateDiagnosticDescriptor( string name, string id, string category, DiagnosticSeverity defaultSeverity, bool isEnabledByDefault) { var title = GetDiagnosticResourceString(name, nameof(DiagnosticDescriptor.Title)); var messageFormat = GetDiagnosticResourceString(name, nameof(DiagnosticDescriptor.MessageFormat)); var description = GetDiagnosticResourceString(name, nameof(DiagnosticDescriptor.Description)); return new DiagnosticDescriptor(id, title, messageFormat, category, defaultSeverity, isEnabledByDefault, description); }
public static CodeAction Create(TextSpan textSpan, DiagnosticSeverity severity, string description, Solution changedSolution) { if (description == null) throw new ArgumentNullException(nameof(description)); if (changedSolution == null) throw new ArgumentNullException(nameof(changedSolution)); return new DocumentChangeAction(textSpan, severity, description, ct => Task.FromResult<Solution>(changedSolution)); }
public static CodeAction Create(TextSpan textSpan, DiagnosticSeverity severity, string description, Document changedDocument) { if (description == null) throw new ArgumentNullException("description"); if (changedDocument == null) throw new ArgumentNullException("changedDocument"); return new DocumentChangeAction(textSpan, severity, description, ct => Task.FromResult<Document>(changedDocument)); }
public NamingRule(string title, ImmutableArray<NamingRule> children, SymbolSpecification symbolSpecification, NamingStyle namingStyle, DiagnosticSeverity enforcementLevel) { Title = title; Children = children; SymbolSpecification = symbolSpecification; NamingStyle = namingStyle; EnforcementLevel = enforcementLevel; }
public static CodeAction CreateInsertion(TextSpan textSpan, DiagnosticSeverity severity, string description, Func<CancellationToken, Task<InsertionResult>> createInsertion) { if (description == null) throw new ArgumentNullException(nameof(description)); if (createInsertion == null) throw new ArgumentNullException(nameof(createInsertion)); return new InsertionAction(textSpan, severity, description, createInsertion); }
/// <summary> /// DiagnosticRecord: The constructor for DiagnosticRecord class. /// </summary> /// <param name="message">A string about why this diagnostic was created</param> /// <param name="extent">The place in the script this diagnostic refers to</param> /// <param name="ruleName">The name of the rule that created this diagnostic</param> /// <param name="severity">The severity of this diagnostic</param> /// <param name="scriptName">The name of the script file being analyzed</param> public DiagnosticRecord(string message, IScriptExtent extent, string ruleName, DiagnosticSeverity severity, string scriptName, string ruleId = null) { Message = string.IsNullOrEmpty(message) ? string.Empty : message; RuleName = string.IsNullOrEmpty(ruleName) ? string.Empty : ruleName; Extent = extent; Severity = severity; ScriptName = string.IsNullOrEmpty(scriptName) ? string.Empty : scriptName; ruleSuppressionId = ruleId; }
internal override Diagnostic WithSeverity(DiagnosticSeverity severity) { if (this.Severity != severity) { return new CSDiagnostic(this.Info.GetInstanceWithSeverity(severity), this.Location); } return this; }
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); }
internal DiagnosticResult(Type serviceType, string description, DiagnosticType diagnosticType, DiagnosticSeverity severity, object value) { this.ServiceType = serviceType; this.Description = description; this.DiagnosticType = diagnosticType; this.Severity = severity; this.Value = value; }
internal static SimpleDiagnostic Create(string id, LocalizableString title, string category, LocalizableString message, LocalizableString description, string helpLink, DiagnosticSeverity severity, DiagnosticSeverity defaultSeverity, bool isEnabledByDefault, int warningLevel, Location location, IEnumerable<Location> additionalLocations, IEnumerable<string> customTags) { var descriptor = new DiagnosticDescriptor(id, title, message, category, defaultSeverity, isEnabledByDefault, description, helpLink, customTags.ToImmutableArrayOrEmpty()); return new SimpleDiagnostic(descriptor, severity, warningLevel, location, additionalLocations, messageArgs: null); }
public TestDiagnostic(DiagnosticDescriptor descriptor, string kind, DiagnosticSeverity severity, Location location, string message, params object[] arguments) { _descriptor = descriptor; _kind = kind; _severity = severity; _location = location; _message = message; _arguments = arguments; }
private DiagnosticInfo(DiagnosticInfo original, DiagnosticSeverity overridenSeverity) { _messageProvider = original.MessageProvider; _errorCode = original._errorCode; _defaultSeverity = original.DefaultSeverity; _arguments = original._arguments; _effectiveSeverity = overridenSeverity; }
/// <summary> /// Given a message identifier (e.g., CS0219), severity, warning as error and a culture, /// get the entire prefix (e.g., "error CS0219: Warning as Error:" for C# or "error BC42024:" for VB) used on error messages. /// </summary> public abstract string GetMessagePrefix(string id, DiagnosticSeverity severity, bool isWarningAsError, CultureInfo culture);
protected DiagnosticDescriptor CreateDescriptorWithTitle(LocalizableString title, DiagnosticSeverity severity, params string[] customTags) => CreateDescriptorWithId(DescriptorId, title, title, severity, customTags);
// Given a message identifier (e.g., CS0219), severity, warning as error and a culture, // get the entire prefix (e.g., "error CS0219:" for C#) used on error messages. public override string GetMessagePrefix(string id, DiagnosticSeverity severity, bool isWarningAsError, CultureInfo culture) { return(String.Format(culture, "{0} {1}", severity == DiagnosticSeverity.Error || isWarningAsError ? "error" : "warning", id)); }
public static NotificationOption ToNotificationOption(this ReportDiagnostic reportDiagnostic, DiagnosticSeverity defaultSeverity) { switch (reportDiagnostic.WithDefaultSeverity(defaultSeverity)) { case ReportDiagnostic.Error: return(NotificationOption.Error); case ReportDiagnostic.Warn: return(NotificationOption.Warning); case ReportDiagnostic.Info: return(NotificationOption.Suggestion); case ReportDiagnostic.Hidden: return(NotificationOption.Silent); case ReportDiagnostic.Suppress: return(NotificationOption.None); case ReportDiagnostic.Default: default: throw ExceptionUtilities.UnexpectedValue(reportDiagnostic); } }
/// <summary> /// Returns the equivalent <see cref="ReportDiagnostic"/> for a <see cref="DiagnosticSeverity"/> value. /// </summary> /// <param name="diagnosticSeverity">The <see cref="DiagnosticSeverity"/> value.</param> /// <returns> /// The equivalent <see cref="ReportDiagnostic"/> for the <see cref="DiagnosticSeverity"/> value. /// </returns> /// <exception cref="InvalidOperationException"> /// If <paramref name="diagnosticSeverity"/> is not one of the expected values. /// </exception> public static ReportDiagnostic ToReportDiagnostic(this DiagnosticSeverity diagnosticSeverity) => diagnosticSeverity switch {
/// <summary> /// Create a new instance of this diagnostic with the Severity property changed. /// </summary> internal abstract Diagnostic WithSeverity(DiagnosticSeverity severity);
// Create a copy of this instance with a explicit overridden severity internal virtual DiagnosticInfo GetInstanceWithSeverity(DiagnosticSeverity severity) => new(this, severity);
private bool TryCheckVariableAndIfStatementForm( SyntaxNodeAnalysisContext syntaxContext, IfStatementSyntax ifStatement, BinaryExpressionSyntax condition, ExpressionStatementSyntax expressionStatement, InvocationExpressionSyntax invocationExpression, DiagnosticSeverity severity) { var cancellationToken = syntaxContext.CancellationToken; cancellationToken.ThrowIfCancellationRequested(); // look for the form "if (a != null)" or "if (null != a)" if (!ifStatement.Parent.IsKind(SyntaxKind.Block)) { return(false); } if (!IsNullCheckExpression(condition.Left, condition.Right) && !IsNullCheckExpression(condition.Right, condition.Left)) { return(false); } var expression = invocationExpression.Expression; if (!expression.IsKind(SyntaxKind.IdentifierName)) { return(false); } var conditionName = condition.Left is IdentifierNameSyntax ? (IdentifierNameSyntax)condition.Left : (IdentifierNameSyntax)condition.Right; var invocationName = (IdentifierNameSyntax)expression; if (!Equals(conditionName.Identifier.ValueText, invocationName.Identifier.ValueText)) { return(false); } // Now make sure the previous statement is "var a = ..." var parentBlock = (BlockSyntax)ifStatement.Parent; var ifIndex = parentBlock.Statements.IndexOf(ifStatement); if (ifIndex == 0) { return(false); } var previousStatement = parentBlock.Statements[ifIndex - 1]; if (!previousStatement.IsKind(SyntaxKind.LocalDeclarationStatement)) { return(false); } var localDeclarationStatement = (LocalDeclarationStatementSyntax)previousStatement; var variableDeclaration = localDeclarationStatement.Declaration; if (variableDeclaration.Variables.Count != 1) { return(false); } var declarator = variableDeclaration.Variables[0]; if (declarator.Initializer == null) { return(false); } cancellationToken.ThrowIfCancellationRequested(); if (!Equals(declarator.Identifier.ValueText, conditionName.Identifier.ValueText)) { return(false); } // Syntactically this looks good. Now make sure that the local is a delegate type. var semanticModel = syntaxContext.SemanticModel; var localSymbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(declarator, cancellationToken); // Ok, we made a local just to check it for null and invoke it. Looks like something // we can suggest an improvement for! // But first make sure we're only using the local only within the body of this if statement. var analysis = semanticModel.AnalyzeDataFlow(localDeclarationStatement, ifStatement); if (analysis.ReadOutside.Contains(localSymbol) || analysis.WrittenOutside.Contains(localSymbol)) { return(false); } // Looks good! var tree = semanticModel.SyntaxTree; var additionalLocations = new List <Location> { Location.Create(tree, localDeclarationStatement.Span), Location.Create(tree, ifStatement.Span), Location.Create(tree, expressionStatement.Span) }; ReportDiagnostics(syntaxContext, localDeclarationStatement, ifStatement, expressionStatement, severity, additionalLocations, Constants.VariableAndIfStatementForm); return(true); }
public override string GetMessagePrefix(string id, DiagnosticSeverity severity, bool isWarningAsError, CultureInfo culture) { throw new NotImplementedException(); }
public Diagnostic(DiagnosticSeverity severity, string message);
public Diagnostic(Range range, DiagnosticSeverity severity, string message, string id);
internal override Diagnostic WithSeverity(DiagnosticSeverity severity) { return(new CompilerDiagnostic(_original.WithSeverity(severity), _properties)); }
private static DiagnosticDescriptor GetOrCreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider) => ImmutableInterlocked.GetOrAdd(ref s_errorCodeToDescriptorMap, errorCode, code => CreateDescriptor(code, defaultSeverity, messageProvider));
public FixCommand( FixCommandLineOptions options, DiagnosticSeverity severityLevel, IEnumerable <KeyValuePair <string, string> > diagnosticFixMap, IEnumerable <KeyValuePair <string, string> > diagnosticFixerMap, in ProjectFilter projectFilter) : base(projectFilter)
private static int GetWarningLevel(DiagnosticSeverity severity) { return(severity == DiagnosticSeverity.Error ? 0 : 1); }
/// <summary> /// Take a warning and return the final disposition of the given warning, /// based on both command line options and pragmas. The diagnostic options /// have precedence in the following order: /// 1. Warning level /// 2. Command line options (/nowarn, /warnaserror) /// 3. Editor config options (syntax tree level) /// 4. Global analyzer config options (compilation level) /// 5. Global warning level /// /// Pragmas are considered separately. If a diagnostic would not otherwise /// be suppressed, but is suppressed by a pragma, <paramref name="hasPragmaSuppression"/> /// is true but the diagnostic is not reported as suppressed. /// </summary> internal static ReportDiagnostic GetDiagnosticReport( DiagnosticSeverity severity, bool isEnabledByDefault, string id, int diagnosticWarningLevel, Location location, string category, int warningLevelOption, NullableContextOptions nullableOption, ReportDiagnostic generalDiagnosticOption, IDictionary <string, ReportDiagnostic> specificDiagnosticOptions, SyntaxTreeOptionsProvider?syntaxTreeOptions, CancellationToken cancellationToken, out bool hasPragmaSuppression ) { hasPragmaSuppression = false; Debug.Assert(location.SourceTree is null || location.SourceTree is CSharpSyntaxTree); var tree = location.SourceTree as CSharpSyntaxTree; var position = location.SourceSpan.Start; bool isNullableFlowAnalysisWarning = ErrorFacts.NullableWarnings.Contains(id); if (isNullableFlowAnalysisWarning) { Syntax.NullableContextState.State?warningsState = tree?.GetNullableContextState( position ).WarningsState; var nullableWarningsEnabled = warningsState switch { Syntax.NullableContextState.State.Enabled => true, Syntax.NullableContextState.State.Disabled => false, Syntax.NullableContextState.State.ExplicitlyRestored => nullableOption.WarningsEnabled(), Syntax.NullableContextState.State.Unknown => tree?.IsGeneratedCode(syntaxTreeOptions, cancellationToken) != true && nullableOption.WarningsEnabled(), null => nullableOption.WarningsEnabled(), _ => throw ExceptionUtilities.UnexpectedValue(warningsState) }; if (!nullableWarningsEnabled) { return(ReportDiagnostic.Suppress); } } // 1. Warning level if (diagnosticWarningLevel > warningLevelOption) // honor the warning level { return(ReportDiagnostic.Suppress); } ReportDiagnostic report; bool isSpecified = false; bool specifiedWarnAsErrorMinus = false; if (specificDiagnosticOptions.TryGetValue(id, out report)) { // 2. Command line options (/nowarn, /warnaserror) isSpecified = true; // 'ReportDiagnostic.Default' is added to SpecificDiagnosticOptions for "/warnaserror-:DiagnosticId", if (report == ReportDiagnostic.Default) { specifiedWarnAsErrorMinus = true; } } // Apply syntax tree options, if applicable. if (syntaxTreeOptions != null && (!isSpecified || specifiedWarnAsErrorMinus)) { // 3. Editor config options (syntax tree level) // 4. Global analyzer config options (compilation level) // Do not apply config options if it is bumping a warning to an error and "/warnaserror-:DiagnosticId" was specified on the command line. if ( ( tree != null && syntaxTreeOptions.TryGetDiagnosticValue( tree, id, cancellationToken, out var reportFromSyntaxTreeOptions ) || syntaxTreeOptions.TryGetGlobalDiagnosticValue( id, cancellationToken, out reportFromSyntaxTreeOptions ) ) && !( specifiedWarnAsErrorMinus && severity == DiagnosticSeverity.Warning && reportFromSyntaxTreeOptions == ReportDiagnostic.Error ) ) { isSpecified = true; report = reportFromSyntaxTreeOptions; // '/warnaserror' should promote warnings configured in analyzer config to error. if ( !specifiedWarnAsErrorMinus && report == ReportDiagnostic.Warn && generalDiagnosticOption == ReportDiagnostic.Error ) { report = ReportDiagnostic.Error; } } } if (!isSpecified) { report = isEnabledByDefault ? ReportDiagnostic.Default : ReportDiagnostic.Suppress; } if (report == ReportDiagnostic.Suppress) { return(ReportDiagnostic.Suppress); } // If location.SourceTree is available, check out pragmas var pragmaWarningState = tree?.GetPragmaDirectiveWarningState(id, position) ?? Syntax.PragmaWarningState.Default; if (pragmaWarningState == Syntax.PragmaWarningState.Disabled) { hasPragmaSuppression = true; } // NOTE: this may be removed as part of https://github.com/dotnet/roslyn/issues/36550 if (pragmaWarningState == Syntax.PragmaWarningState.Enabled) { switch (report) { case ReportDiagnostic.Error: case ReportDiagnostic.Hidden: case ReportDiagnostic.Info: case ReportDiagnostic.Warn: // No need to adjust the current report state, it already means "enabled" return(report); case ReportDiagnostic.Suppress: // Enable the warning return(ReportDiagnostic.Default); case ReportDiagnostic.Default: if (generalDiagnosticOption == ReportDiagnostic.Error && promoteToAnError()) { return(ReportDiagnostic.Error); } return(ReportDiagnostic.Default); default: throw ExceptionUtilities.UnexpectedValue(report); } } else if (report == ReportDiagnostic.Suppress) // check options (/nowarn) { return(ReportDiagnostic.Suppress); } // 5. Global options // Unless specific warning options are defined (/warnaserror[+|-]:<n> or /nowarn:<n>, // follow the global option (/warnaserror[+|-] or /nowarn). if (report == ReportDiagnostic.Default) { switch (generalDiagnosticOption) { case ReportDiagnostic.Error: if (promoteToAnError()) { return(ReportDiagnostic.Error); } break; case ReportDiagnostic.Suppress: // When doing suppress-all-warnings, don't lower severity for anything other than warning and info. // We shouldn't suppress hidden diagnostics here because then features that use hidden diagnostics to // display a lightbulb would stop working if someone has suppress-all-warnings (/nowarn) specified in their project. if ( severity == DiagnosticSeverity.Warning || severity == DiagnosticSeverity.Info ) { report = ReportDiagnostic.Suppress; isSpecified = true; } break; } } return(report); bool promoteToAnError() { Debug.Assert(report == ReportDiagnostic.Default); Debug.Assert(generalDiagnosticOption == ReportDiagnostic.Error); // If we've been asked to do warn-as-error then don't raise severity for anything below warning (info or hidden). return(severity == DiagnosticSeverity.Warning && // In the case where /warnaserror+ is followed by /warnaserror-:<n> on the command line, // do not promote the warning specified in <n> to an error. !isSpecified); } } }
internal override Diagnostic WithSeverity(DiagnosticSeverity severity) { throw new NotImplementedException(); }
public TestDiagnostic(string id, string kind, DiagnosticSeverity severity, Location location, string message, params object[] arguments) : this(new DiagnosticDescriptor(id, string.Empty, message, id, severity, isEnabledByDefault : true), kind, severity, location, message, arguments) { }
/// <summary> /// Take a warning and return the final disposition of the given warning, /// based on both command line options and pragmas. The diagnostic options /// have precedence in the following order: /// 1. Warning level /// 2. Syntax tree level /// 3. Compilation level /// 4. Global warning level /// /// Pragmas are considered seperately. If a diagnostic would not otherwise /// be suppressed, but is suppressed by a pragma, <paramref name="hasPragmaSuppression"/> /// is true but the diagnostic is not reported as suppressed. /// </summary> internal static ReportDiagnostic GetDiagnosticReport( DiagnosticSeverity severity, bool isEnabledByDefault, string id, int diagnosticWarningLevel, Location location, string category, int warningLevelOption, NullableContextOptions nullableOption, ReportDiagnostic generalDiagnosticOption, IDictionary <string, ReportDiagnostic> specificDiagnosticOptions, out bool hasPragmaSuppression) { hasPragmaSuppression = false; Debug.Assert(location?.SourceTree is null || location.SourceTree is CSharpSyntaxTree); var tree = location?.SourceTree as CSharpSyntaxTree; var position = location.SourceSpan.Start; bool isNullableFlowAnalysisWarning = ErrorFacts.NullableWarnings.Contains(id); if (isNullableFlowAnalysisWarning) { var nullableWarningsGloballyEnabled = nullableOption == NullableContextOptions.Enable || nullableOption == NullableContextOptions.Warnings; var nullableWarningsEnabled = tree?.GetNullableContextState(position).WarningsState ?? nullableWarningsGloballyEnabled; if (!nullableWarningsEnabled) { return(ReportDiagnostic.Suppress); } } // 1. Warning level if (diagnosticWarningLevel > warningLevelOption) // honor the warning level { return(ReportDiagnostic.Suppress); } ReportDiagnostic report; bool isSpecified = false; if (tree != null && tree.DiagnosticOptions.TryGetValue(id, out var treeReport)) { // 2. Syntax tree level report = treeReport; isSpecified = true; } else if (specificDiagnosticOptions.TryGetValue(id, out var specificReport)) { // 3. Compilation level report = specificReport; isSpecified = true; } else { report = isEnabledByDefault ? ReportDiagnostic.Default : ReportDiagnostic.Suppress; } if (report == ReportDiagnostic.Suppress) { return(ReportDiagnostic.Suppress); } // If location.SourceTree is available, check out pragmas var pragmaWarningState = tree?.GetPragmaDirectiveWarningState(id, position) ?? Syntax.PragmaWarningState.Default; if (pragmaWarningState == Syntax.PragmaWarningState.Disabled) { hasPragmaSuppression = true; } // NOTE: this may be removed as part of https://github.com/dotnet/roslyn/issues/36550 if (pragmaWarningState == Syntax.PragmaWarningState.Enabled) { switch (report) { case ReportDiagnostic.Error: case ReportDiagnostic.Hidden: case ReportDiagnostic.Info: case ReportDiagnostic.Warn: // No need to adjust the current report state, it already means "enabled" return(report); case ReportDiagnostic.Suppress: // Enable the warning return(ReportDiagnostic.Default); case ReportDiagnostic.Default: if (generalDiagnosticOption == ReportDiagnostic.Error && promoteToAnError()) { return(ReportDiagnostic.Error); } return(ReportDiagnostic.Default); default: throw ExceptionUtilities.UnexpectedValue(report); } } else if (report == ReportDiagnostic.Suppress) // check options (/nowarn) { return(ReportDiagnostic.Suppress); } // 4. Global options // Unless specific warning options are defined (/warnaserror[+|-]:<n> or /nowarn:<n>, // follow the global option (/warnaserror[+|-] or /nowarn). if (report == ReportDiagnostic.Default) { switch (generalDiagnosticOption) { case ReportDiagnostic.Error: if (promoteToAnError()) { return(ReportDiagnostic.Error); } break; case ReportDiagnostic.Suppress: // When doing suppress-all-warnings, don't lower severity for anything other than warning and info. // We shouldn't suppress hidden diagnostics here because then features that use hidden diagnostics to // display a lightbulb would stop working if someone has suppress-all-warnings (/nowarn) specified in their project. if (severity == DiagnosticSeverity.Warning || severity == DiagnosticSeverity.Info) { report = ReportDiagnostic.Suppress; } break; } } return(report); bool promoteToAnError() { Debug.Assert(report == ReportDiagnostic.Default); Debug.Assert(generalDiagnosticOption == ReportDiagnostic.Error); // If we've been asked to do warn-as-error then don't raise severity for anything below warning (info or hidden). return(severity == DiagnosticSeverity.Warning && // In the case where /warnaserror+ is followed by /warnaserror-:<n> on the command line, // do not promote the warning specified in <n> to an error. !isSpecified); } }
protected NRefactoryCodeAction(TextSpan textSpan, DiagnosticSeverity severity) { TextSpan = textSpan; Severity = severity; }
/// <summary> /// Applies a default severity to a <see cref="ReportDiagnostic"/> value. /// </summary> /// <param name="reportDiagnostic">The <see cref="ReportDiagnostic"/> value.</param> /// <param name="defaultSeverity">The default severity.</param> /// <returns> /// <para>If <paramref name="reportDiagnostic"/> is <see cref="ReportDiagnostic.Default"/>, returns /// <paramref name="defaultSeverity"/>.</para> /// <para>-or-</para> /// <para>Otherwise, returns <paramref name="reportDiagnostic"/> if it has a non-default value.</para> /// </returns> public static ReportDiagnostic WithDefaultSeverity(this ReportDiagnostic reportDiagnostic, DiagnosticSeverity defaultSeverity) { if (reportDiagnostic != ReportDiagnostic.Default) { return(reportDiagnostic); } return(defaultSeverity.ToReportDiagnostic()); }
private static ImmutableArray <string> GetCustomTags(DiagnosticSeverity defaultSeverity) { return(defaultSeverity == DiagnosticSeverity.Error ? s_compilerErrorCustomTags : s_compilerNonErrorCustomTags); }
internal override Diagnostic WithSeverity(DiagnosticSeverity severity) { return(new TestDiagnostic(_descriptor, _kind, severity, _location, _message, _arguments)); }
protected DiagnosticDescriptor CreateDescriptorWithId(string id, LocalizableString title, LocalizableString message, DiagnosticSeverity severity, params string[] customTags) => new DiagnosticDescriptor( id, title, message, DiagnosticCategory.Style, severity, isEnabledByDefault: true, customTags: customTags);
private Diagnostic BuildTemplatesDiagnostic(string errorMessage, ParserRuleContext context, DiagnosticSeverity severity = DiagnosticSeverity.Error) { return(new Diagnostic(context.ConvertToRange(), errorMessage, severity, _templates.Source)); }
public NamingRule(SymbolSpecification symbolSpecification, NamingStyle namingStyle, DiagnosticSeverity enforcementLevel) { SymbolSpecification = symbolSpecification; NamingStyle = namingStyle; EnforcementLevel = enforcementLevel; }
// Create a copy of this instance with a explicit overridden severity internal DiagnosticInfo GetInstanceWithSeverity(DiagnosticSeverity severity) { return(new DiagnosticInfo(this, severity)); }
public override string GetMessagePrefix(string id, DiagnosticSeverity severity, bool isWarningAsError, CultureInfo culture) { return(MessageProvider.Instance.GetMessagePrefix(id, severity, isWarningAsError, culture)); }
/// <summary> /// checks if style is preferred and the enforcement is not None. /// </summary> /// <remarks>if predefined type is not preferred, it implies the preference is framework type.</remarks> private static bool OptionSettingPrefersFrameworkType(CodeStyleOption <bool> optionValue, DiagnosticSeverity severity) => !optionValue.Value && severity != DiagnosticSeverity.Hidden;
protected DiagnosticDescriptor CreateDescriptorWithSeverity(DiagnosticSeverity severity, params string[] customTags) => CreateDescriptorWithId(DescriptorId, _localizableTitle, _localizableMessage, severity, customTags);