private Location GetIncludeElementLocation(XElement includeElement, ref string currentXmlFilePath, ref CSharpSyntaxNode originatingSyntax)
{
Location location = includeElement.Annotation <Location>();
if (location != null)
{
return(location);
}
// If we are not in an XML file, then we must be in a source file. Since we're traversing the XML tree in the same
// order as the DocumentationCommentWalker, we can access the elements of includeElementNodes in order.
if (currentXmlFilePath == null)
{
Debug.Assert(_nextSourceIncludeElementIndex < _sourceIncludeElementNodes.Length);
Debug.Assert(originatingSyntax == null);
originatingSyntax = _sourceIncludeElementNodes[_nextSourceIncludeElementIndex];
location = originatingSyntax.Location;
_nextSourceIncludeElementIndex++;
// #line shall not affect the base path:
currentXmlFilePath = location.GetLineSpan().Path;
}
else
{
location = XmlLocation.Create(includeElement, currentXmlFilePath);
}
Debug.Assert(location != null);
includeElement.AddAnnotation(location);
return(location);
}
private static void VerifyDiagnosticLocation(Diagnostic diagnostic, Location actual, DiagnosticResultLocation expected)
{
var actualSpan = actual.GetLineSpan();
Assert.True(actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")),
string.Format("Expected diagnostic to be in file \"{0}\" was actually in file \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n",
expected.Path, actualSpan.Path, diagnostic));
var actualLinePosition = actualSpan.StartLinePosition;
// Only check line position if there is an actual line in the real diagnostic
if (actualLinePosition.Line > 0)
{
Assert.True(actualLinePosition.Line + 1 == expected.Line,
string.Format("Expected diagnostic to be on line \"{0}\" was actually on line \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n",
expected.Line, actualLinePosition.Line + 1, diagnostic));
}
// Only check column position if there is an actual column position in the real diagnostic
if (actualLinePosition.Character > 0)
{
Assert.True(actualLinePosition.Character + 1 == expected.Column,
string.Format("Expected diagnostic to start at column \"{0}\" was actually at column \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n",
expected.Column, actualLinePosition.Character + 1, diagnostic));
}
}
// Take a warning and return the final deposition of the given warning,
// based on both command line options and pragmas.
internal static ReportDiagnostic GetDiagnosticReport(
DiagnosticSeverity severity,
bool isEnabledByDefault,
string id,
int diagnosticWarningLevel,
Location location,
string category,
int warningLevelOption,
ReportDiagnostic generalDiagnosticOption,
IDictionary <string, ReportDiagnostic> specificDiagnosticOptions,
out bool hasPragmaSuppression)
{
hasPragmaSuppression = false;
// 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 XSHARP
// X# does not include the pragma directives in the SyntaxTree
// That is why we can't compare positions, but we use line numbers in stead.
if (location != null && location.SourceTree != null)
{
var line = location.GetLineSpan().StartLinePosition.Line;
var tree = ((SyntaxTree)location.SourceTree);
if (tree.GetPragmaDirectiveWarningState(id, line) == ReportDiagnostic.Suppress)
{
hasPragmaSuppression = true;
}
}
#else
if (location != null &&
location.SourceTree != null &&
((SyntaxTree)location.SourceTree).GetPragmaDirectiveWarningState(id, location.SourceSpan.Start) == ReportDiagnostic.Suppress)
{
hasPragmaSuppression = true;
}
#endif
// 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);
}
