lib/Frontend/SARIFDiagnostic.cpp - llvm-project/clang - Git at Google

 //===--------- SARIFDiagnostic.cpp - SARIF Diagnostic Formatting ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "clang/Frontend/SARIFDiagnostic.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/Sarif.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Locale.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <string>

 namespace clang {

 SARIFDiagnostic::SARIFDiagnostic(raw_ostream &OS, const LangOptions &LangOpts,
                                  DiagnosticOptions *DiagOpts,
                                  SarifDocumentWriter *Writer)
     : DiagnosticRenderer(LangOpts, DiagOpts), Writer(Writer) {}

 // FIXME(llvm-project/issues/57323): Refactor Diagnostic classes.
 void SARIFDiagnostic::emitDiagnosticMessage(
     FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
     StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
     DiagOrStoredDiag D) {

   const auto *Diag = D.dyn_cast<const Diagnostic *>();

   if (!Diag)
     return;

   SarifRule Rule = SarifRule::create().setRuleId(std::to_string(Diag->getID()));

   Rule = addDiagnosticLevelToRule(Rule, Level);

   unsigned RuleIdx = Writer->createRule(Rule);

   SarifResult Result =
       SarifResult::create(RuleIdx).setDiagnosticMessage(Message);

   if (Loc.isValid())
     Result = addLocationToResult(Result, Loc, PLoc, Ranges, *Diag);

   Writer->appendResult(Result);
 }

 SarifResult SARIFDiagnostic::addLocationToResult(
     SarifResult Result, FullSourceLoc Loc, PresumedLoc PLoc,
     ArrayRef<CharSourceRange> Ranges, const Diagnostic &Diag) {
   SmallVector<CharSourceRange> Locations = {};

   if (PLoc.isInvalid()) {
     // At least add the file name if available:
     FileID FID = Loc.getFileID();
     if (FID.isValid()) {
       if (OptionalFileEntryRef FE = Loc.getFileEntryRef()) {
         emitFilename(FE->getName(), Loc.getManager());
         // FIXME(llvm-project/issues/57366): File-only locations
       }
     }
     return Result;
   }

   FileID CaretFileID = Loc.getExpansionLoc().getFileID();

   for (const CharSourceRange Range : Ranges) {
     // Ignore invalid ranges.
     if (Range.isInvalid())
       continue;

     auto &SM = Loc.getManager();
     SourceLocation B = SM.getExpansionLoc(Range.getBegin());
     CharSourceRange ERange = SM.getExpansionRange(Range.getEnd());
     SourceLocation E = ERange.getEnd();
     bool IsTokenRange = ERange.isTokenRange();

     std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
     std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);

     // If the start or end of the range is in another file, just discard
     // it.
     if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
       continue;

     // Add in the length of the token, so that we cover multi-char
     // tokens.
     unsigned TokSize = 0;
     if (IsTokenRange)
       TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);

     FullSourceLoc BF(B, SM), EF(E, SM);
     SourceLocation BeginLoc = SM.translateLineCol(
         BF.getFileID(), BF.getLineNumber(), BF.getColumnNumber());
     SourceLocation EndLoc = SM.translateLineCol(
         EF.getFileID(), EF.getLineNumber(), EF.getColumnNumber() + TokSize);

     Locations.push_back(
         CharSourceRange{SourceRange{BeginLoc, EndLoc}, /* ITR = */ false});
     // FIXME: Additional ranges should use presumed location in both
     // Text and SARIF diagnostics.
   }

   auto &SM = Loc.getManager();
   auto FID = PLoc.getFileID();
   // Visual Studio 2010 or earlier expects column number to be off by one.
   unsigned int ColNo = (LangOpts.MSCompatibilityVersion &&
                         !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
                            ? PLoc.getColumn() - 1
                            : PLoc.getColumn();
   SourceLocation DiagLoc = SM.translateLineCol(FID, PLoc.getLine(), ColNo);

   // FIXME(llvm-project/issues/57366): Properly process #line directives.
   Locations.push_back(
       CharSourceRange{SourceRange{DiagLoc, DiagLoc}, /* ITR = */ false});

   return Result.setLocations(Locations);
 }

 SarifRule
 SARIFDiagnostic::addDiagnosticLevelToRule(SarifRule Rule,
                                           DiagnosticsEngine::Level Level) {
   auto Config = SarifReportingConfiguration::create();

   switch (Level) {
   case DiagnosticsEngine::Note:
     Config = Config.setLevel(SarifResultLevel::Note);
     break;
   case DiagnosticsEngine::Remark:
     Config = Config.setLevel(SarifResultLevel::None);
     break;
   case DiagnosticsEngine::Warning:
     Config = Config.setLevel(SarifResultLevel::Warning);
     break;
   case DiagnosticsEngine::Error:
     Config = Config.setLevel(SarifResultLevel::Error).setRank(50);
     break;
   case DiagnosticsEngine::Fatal:
     Config = Config.setLevel(SarifResultLevel::Error).setRank(100);
     break;
   case DiagnosticsEngine::Ignored:
     assert(false && "Invalid diagnostic type");
   }

   return Rule.setDefaultConfiguration(Config);
 }

 llvm::StringRef SARIFDiagnostic::emitFilename(StringRef Filename,
                                               const SourceManager &SM) {
   if (DiagOpts->AbsolutePath) {
     auto File = SM.getFileManager().getOptionalFileRef(Filename);
     if (File) {
       // We want to print a simplified absolute path, i. e. without "dots".
       //
       // The hardest part here are the paths like "<part1>/<link>/../<part2>".
       // On Unix-like systems, we cannot just collapse "<link>/..", because
       // paths are resolved sequentially, and, thereby, the path
       // "<part1>/<part2>" may point to a different location. That is why
       // we use FileManager::getCanonicalName(), which expands all indirections
       // with llvm::sys::fs::real_path() and caches the result.
       //
       // On the other hand, it would be better to preserve as much of the
       // original path as possible, because that helps a user to recognize it.
       // real_path() expands all links, which is sometimes too much. Luckily,
       // on Windows we can just use llvm::sys::path::remove_dots(), because,
       // on that system, both aforementioned paths point to the same place.
 #ifdef _WIN32
       SmallString<256> TmpFilename = File->getName();
       llvm::sys::fs::make_absolute(TmpFilename);
       llvm::sys::path::native(TmpFilename);
       llvm::sys::path::remove_dots(TmpFilename, /* remove_dot_dot */ true);
       Filename = StringRef(TmpFilename.data(), TmpFilename.size());
 #else
       Filename = SM.getFileManager().getCanonicalName(*File);
 #endif
     }
   }

   return Filename;
 }

 /// Print out the file/line/column information and include trace.
 ///
 /// This method handlen the emission of the diagnostic location information.
 /// This includes extracting as much location information as is present for
 /// the diagnostic and printing it, as well as any include stack or source
 /// ranges necessary.
 void SARIFDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
                                         DiagnosticsEngine::Level Level,
                                         ArrayRef<CharSourceRange> Ranges) {
   assert(false && "Not implemented in SARIF mode");
 }

 void SARIFDiagnostic::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) {
   assert(false && "Not implemented in SARIF mode");
 }

 void SARIFDiagnostic::emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
                                          StringRef ModuleName) {
   assert(false && "Not implemented in SARIF mode");
 }

 void SARIFDiagnostic::emitBuildingModuleLocation(FullSourceLoc Loc,
                                                  PresumedLoc PLoc,
                                                  StringRef ModuleName) {
   assert(false && "Not implemented in SARIF mode");
 }
 } // namespace clang
	//===--------- SARIFDiagnostic.cpp - SARIF Diagnostic Formatting ----------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "clang/Frontend/SARIFDiagnostic.h"
	#include "clang/Basic/CharInfo.h"
	#include "clang/Basic/DiagnosticOptions.h"
	#include "clang/Basic/FileManager.h"
	#include "clang/Basic/Sarif.h"
	#include "clang/Basic/SourceLocation.h"
	#include "clang/Basic/SourceManager.h"
	#include "clang/Lex/Lexer.h"
	#include "llvm/ADT/ArrayRef.h"
	#include "llvm/ADT/SmallString.h"
	#include "llvm/ADT/StringExtras.h"
	#include "llvm/ADT/StringRef.h"
	#include "llvm/Support/Casting.h"
	#include "llvm/Support/ConvertUTF.h"
	#include "llvm/Support/ErrorHandling.h"
	#include "llvm/Support/ErrorOr.h"
	#include "llvm/Support/Locale.h"
	#include "llvm/Support/Path.h"
	#include "llvm/Support/raw_ostream.h"
	#include <algorithm>
	#include <string>

	namespace clang {

	SARIFDiagnostic::SARIFDiagnostic(raw_ostream &OS, const LangOptions &LangOpts,
	DiagnosticOptions *DiagOpts,
	SarifDocumentWriter *Writer)
	: DiagnosticRenderer(LangOpts, DiagOpts), Writer(Writer) {}

	// FIXME(llvm-project/issues/57323): Refactor Diagnostic classes.
	void SARIFDiagnostic::emitDiagnosticMessage(
	FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
	StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
	DiagOrStoredDiag D) {

	const auto Diag = D.dyn_cast<const Diagnostic >();

	if (!Diag)
	return;

	SarifRule Rule = SarifRule::create().setRuleId(std::to_string(Diag->getID()));

	Rule = addDiagnosticLevelToRule(Rule, Level);

	unsigned RuleIdx = Writer->createRule(Rule);

	SarifResult Result =
	SarifResult::create(RuleIdx).setDiagnosticMessage(Message);

	if (Loc.isValid())
	Result = addLocationToResult(Result, Loc, PLoc, Ranges, *Diag);

	Writer->appendResult(Result);
	}

	SarifResult SARIFDiagnostic::addLocationToResult(
	SarifResult Result, FullSourceLoc Loc, PresumedLoc PLoc,
	ArrayRef<CharSourceRange> Ranges, const Diagnostic &Diag) {
	SmallVector<CharSourceRange> Locations = {};

	if (PLoc.isInvalid()) {
	// At least add the file name if available:
	FileID FID = Loc.getFileID();
	if (FID.isValid()) {
	if (OptionalFileEntryRef FE = Loc.getFileEntryRef()) {
	emitFilename(FE->getName(), Loc.getManager());
	// FIXME(llvm-project/issues/57366): File-only locations
	}
	}
	return Result;
	}

	FileID CaretFileID = Loc.getExpansionLoc().getFileID();

	for (const CharSourceRange Range : Ranges) {
	// Ignore invalid ranges.
	if (Range.isInvalid())
	continue;

	auto &SM = Loc.getManager();
	SourceLocation B = SM.getExpansionLoc(Range.getBegin());
	CharSourceRange ERange = SM.getExpansionRange(Range.getEnd());
	SourceLocation E = ERange.getEnd();
	bool IsTokenRange = ERange.isTokenRange();

	std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
	std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);

	// If the start or end of the range is in another file, just discard
	// it.
	if (BInfo.first != CaretFileID \|\| EInfo.first != CaretFileID)
	continue;

	// Add in the length of the token, so that we cover multi-char
	// tokens.
	unsigned TokSize = 0;
	if (IsTokenRange)
	TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);

	FullSourceLoc BF(B, SM), EF(E, SM);
	SourceLocation BeginLoc = SM.translateLineCol(
	BF.getFileID(), BF.getLineNumber(), BF.getColumnNumber());
	SourceLocation EndLoc = SM.translateLineCol(
	EF.getFileID(), EF.getLineNumber(), EF.getColumnNumber() + TokSize);

	Locations.push_back(
	CharSourceRange{SourceRange{BeginLoc, EndLoc}, /* ITR = */ false});
	// FIXME: Additional ranges should use presumed location in both
	// Text and SARIF diagnostics.
	}

	auto &SM = Loc.getManager();
	auto FID = PLoc.getFileID();
	// Visual Studio 2010 or earlier expects column number to be off by one.
	unsigned int ColNo = (LangOpts.MSCompatibilityVersion &&
	!LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
	? PLoc.getColumn() - 1
	: PLoc.getColumn();
	SourceLocation DiagLoc = SM.translateLineCol(FID, PLoc.getLine(), ColNo);

	// FIXME(llvm-project/issues/57366): Properly process #line directives.
	Locations.push_back(
	CharSourceRange{SourceRange{DiagLoc, DiagLoc}, /* ITR = */ false});

	return Result.setLocations(Locations);
	}

	SarifRule
	SARIFDiagnostic::addDiagnosticLevelToRule(SarifRule Rule,
	DiagnosticsEngine::Level Level) {
	auto Config = SarifReportingConfiguration::create();

	switch (Level) {
	case DiagnosticsEngine::Note:
	Config = Config.setLevel(SarifResultLevel::Note);
	break;
	case DiagnosticsEngine::Remark:
	Config = Config.setLevel(SarifResultLevel::None);
	break;
	case DiagnosticsEngine::Warning:
	Config = Config.setLevel(SarifResultLevel::Warning);
	break;
	case DiagnosticsEngine::Error:
	Config = Config.setLevel(SarifResultLevel::Error).setRank(50);
	break;
	case DiagnosticsEngine::Fatal:
	Config = Config.setLevel(SarifResultLevel::Error).setRank(100);
	break;
	case DiagnosticsEngine::Ignored:
	assert(false && "Invalid diagnostic type");
	}

	return Rule.setDefaultConfiguration(Config);
	}

	llvm::StringRef SARIFDiagnostic::emitFilename(StringRef Filename,
	const SourceManager &SM) {
	if (DiagOpts->AbsolutePath) {
	auto File = SM.getFileManager().getOptionalFileRef(Filename);
	if (File) {
	// We want to print a simplified absolute path, i. e. without "dots".
	//
	// The hardest part here are the paths like "<part1>/<link>/../<part2>".
	// On Unix-like systems, we cannot just collapse "<link>/..", because
	// paths are resolved sequentially, and, thereby, the path
	// "<part1>/<part2>" may point to a different location. That is why
	// we use FileManager::getCanonicalName(), which expands all indirections
	// with llvm::sys::fs::real_path() and caches the result.
	//
	// On the other hand, it would be better to preserve as much of the
	// original path as possible, because that helps a user to recognize it.
	// real_path() expands all links, which is sometimes too much. Luckily,
	// on Windows we can just use llvm::sys::path::remove_dots(), because,
	// on that system, both aforementioned paths point to the same place.
	#ifdef _WIN32
	SmallString<256> TmpFilename = File->getName();
	llvm::sys::fs::make_absolute(TmpFilename);
	llvm::sys::path::native(TmpFilename);
	llvm::sys::path::remove_dots(TmpFilename, /* remove_dot_dot */ true);
	Filename = StringRef(TmpFilename.data(), TmpFilename.size());
	#else
	Filename = SM.getFileManager().getCanonicalName(*File);
	#endif
	}
	}

	return Filename;
	}

	/// Print out the file/line/column information and include trace.
	///
	/// This method handlen the emission of the diagnostic location information.
	/// This includes extracting as much location information as is present for
	/// the diagnostic and printing it, as well as any include stack or source
	/// ranges necessary.
	void SARIFDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
	DiagnosticsEngine::Level Level,
	ArrayRef<CharSourceRange> Ranges) {
	assert(false && "Not implemented in SARIF mode");
	}

	void SARIFDiagnostic::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) {
	assert(false && "Not implemented in SARIF mode");
	}

	void SARIFDiagnostic::emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
	StringRef ModuleName) {
	assert(false && "Not implemented in SARIF mode");
	}

	void SARIFDiagnostic::emitBuildingModuleLocation(FullSourceLoc Loc,
	PresumedLoc PLoc,
	StringRef ModuleName) {
	assert(false && "Not implemented in SARIF mode");
	}
	} // namespace clang