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); }