SourceCoverageView.h

//===- SourceCoverageView.h - Code coverage view for source code ----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
///
/// \file This class implements rendering for code coverage of source code.
///
//===----------------------------------------------------------------------===//

#ifndef LLVM_COV_SOURCECOVERAGEVIEW_H
#defineLLVM_COV_SOURCECOVERAGEVIEW_H

#include"CoverageViewOptions.h"
#include"CoverageSummaryInfo.h"
#include"llvm/ProfileData/Coverage/CoverageMapping.h"
#include"llvm/Support/MemoryBuffer.h"
#include<vector>

namespacellvm {

usingnamespacecoverage;

classCoverageFiltersMatchAll;
classSourceCoverageView;

/// A view that represents a macro or include expansion.
structExpansionView {
 CounterMappingRegion Region;
 std::unique_ptr<SourceCoverageView> View;

ExpansionView(const CounterMappingRegion &Region,
 std::unique_ptr<SourceCoverageView> View)
 : Region(Region), View(std::move(View)) {}
ExpansionView(ExpansionView &&RHS)
 : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
 ExpansionView &operator=(ExpansionView &&RHS) {
 Region = std::move(RHS.Region);
 View = std::move(RHS.View);
return *this;
 }

unsignedgetLine() const { return Region.LineStart; }
unsignedgetStartCol() const { return Region.ColumnStart; }
unsignedgetEndCol() const { return Region.ColumnEnd; }

friendbooloperator<(const ExpansionView &LHS, const ExpansionView &RHS) {
return LHS.Region.startLoc() < RHS.Region.startLoc();
 }
};

/// A view that represents a function instantiation.
structInstantiationView {
 StringRef FunctionName;
unsigned Line;
 std::unique_ptr<SourceCoverageView> View;

InstantiationView(StringRef FunctionName, unsigned Line,
 std::unique_ptr<SourceCoverageView> View)
 : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}

friendbooloperator<(const InstantiationView &LHS,
const InstantiationView &RHS) {
return LHS.Line < RHS.Line;
 }
};

/// A view that represents one or more branch regions on a given source line.
structBranchView {
 std::vector<CountedRegion> Regions;
 std::unique_ptr<SourceCoverageView> View;
unsigned Line;

BranchView(unsigned Line, ArrayRef<CountedRegion> Regions,
 std::unique_ptr<SourceCoverageView> View)
 : Regions(Regions), View(std::move(View)), Line(Line) {}

unsignedgetLine() const { return Line; }

friendbooloperator<(const BranchView &LHS, const BranchView &RHS) {
return LHS.Line < RHS.Line;
 }
};

/// A file manager that handles format-aware file creation.
classCoveragePrinter {
public:
structStreamDestructor {
voidoperator()(raw_ostream *OS) const;
 };

using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;

protected:
const CoverageViewOptions &Opts;

CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}

/// Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
/// false, skip the ToplevelDir component. If \p Relative is false, skip the
/// OutputDir component.
 std::string getOutputPath(StringRef Path, StringRef Extension,
bool InToplevel, bool Relative = true) const;

/// If directory output is enabled, create a file in that directory
/// at the path given by getOutputPath(). Otherwise, return stdout.
 Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
bool InToplevel) const;

/// Return the sub-directory name for file coverage reports.
static StringRef getCoverageDir() { return"coverage"; }

public:
static std::unique_ptr<CoveragePrinter>
create(const CoverageViewOptions &Opts);

virtual~CoveragePrinter() {}

/// @name File Creation Interface
/// @{

/// Create a file to print a coverage view into.
virtual Expected<OwnedStream> createViewFile(StringRef Path,
bool InToplevel) = 0;

/// Close a file which has been used to print a coverage view.
virtualvoidcloseViewFile(OwnedStream OS) = 0;

/// Create an index which lists reports for the given source files.
virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
const CoverageMapping &Coverage,
const CoverageFiltersMatchAll &Filters) = 0;

/// @}
};

/// A code coverage view of a source file or function.
///
/// A source coverage view and its nested sub-views form a file-oriented
/// representation of code coverage data. This view can be printed out by a
/// renderer which implements the Rendering Interface.
classSourceCoverageView {
/// A function or file name.
 StringRef SourceName;

/// A memory buffer backing the source on display.
const MemoryBuffer &File;

/// Various options to guide the coverage renderer.
const CoverageViewOptions &Options;

/// Complete coverage information about the source on display.
 CoverageData CoverageInfo;

/// A container for all expansions (e.g macros) in the source on display.
 std::vector<ExpansionView> ExpansionSubViews;

/// A container for all branches in the source on display.
 std::vector<BranchView> BranchSubViews;

/// A container for all instantiations (e.g template functions) in the source
/// on display.
 std::vector<InstantiationView> InstantiationSubViews;

/// Get the first uncovered line number for the source file.
unsignedgetFirstUncoveredLineNo();

protected:
structLineRef {
 StringRef Line;
int64_t LineNo;

LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {}
 };

using CoverageSegmentArray = ArrayRef<const CoverageSegment *>;

/// @name Rendering Interface
/// @{

/// Render a header for the view.
virtualvoidrenderViewHeader(raw_ostream &OS) = 0;

/// Render a footer for the view.
virtualvoidrenderViewFooter(raw_ostream &OS) = 0;

/// Render the source name for the view.
virtualvoidrenderSourceName(raw_ostream &OS, bool WholeFile) = 0;

/// Render the line prefix at the given \p ViewDepth.
virtualvoidrenderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0;

/// Render the line suffix at the given \p ViewDepth.
virtualvoidrenderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0;

/// Render a view divider at the given \p ViewDepth.
virtualvoidrenderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0;

/// Render a source line with highlighting.
virtualvoidrenderLine(raw_ostream &OS, LineRef L,
const LineCoverageStats &LCS, unsigned ExpansionCol,
unsigned ViewDepth) = 0;

/// Render the line's execution count column.
virtualvoidrenderLineCoverageColumn(raw_ostream &OS,
const LineCoverageStats &Line) = 0;

/// Render the line number column.
virtualvoidrenderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0;

/// Render all the region's execution counts on a line.
virtualvoidrenderRegionMarkers(raw_ostream &OS,
const LineCoverageStats &Line,
unsigned ViewDepth) = 0;

/// Render the site of an expansion.
virtualvoidrenderExpansionSite(raw_ostream &OS, LineRef L,
const LineCoverageStats &LCS,
unsigned ExpansionCol,
unsigned ViewDepth) = 0;

/// Render an expansion view and any nested views.
virtualvoidrenderExpansionView(raw_ostream &OS, ExpansionView &ESV,
unsigned ViewDepth) = 0;

/// Render an instantiation view and any nested views.
virtualvoidrenderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
unsigned ViewDepth) = 0;

/// Render a branch view and any nested views.
virtualvoidrenderBranchView(raw_ostream &OS, BranchView &BRV,
unsigned ViewDepth) = 0;

/// Render \p Title, a project title if one is available, and the
/// created time.
virtualvoidrenderTitle(raw_ostream &OS, StringRef CellText) = 0;

/// Render the table header for a given source file.
virtualvoidrenderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
unsigned IndentLevel) = 0;

/// @}

/// Format a count using engineering notation with 3 significant
/// digits.
static std::string formatCount(uint64_t N);

/// Check if region marker output is expected for a line.
boolshouldRenderRegionMarkers(const LineCoverageStats &LCS) const;

/// Check if there are any sub-views attached to this view.
boolhasSubViews() const;

SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
const CoverageViewOptions &Options,
 CoverageData &&CoverageInfo)
 : SourceName(SourceName), File(File), Options(Options),
CoverageInfo(std::move(CoverageInfo)) {}

public:
static std::unique_ptr<SourceCoverageView>
create(StringRef SourceName, const MemoryBuffer &File,
const CoverageViewOptions &Options, CoverageData &&CoverageInfo);

virtual~SourceCoverageView() {}

/// Return the source name formatted for the host OS.
 std::string getSourceName() const;

const CoverageViewOptions &getOptions() const { return Options; }

/// Add an expansion subview to this view.
voidaddExpansion(const CounterMappingRegion &Region,
 std::unique_ptr<SourceCoverageView> View);

/// Add a function instantiation subview to this view.
voidaddInstantiation(StringRef FunctionName, unsigned Line,
 std::unique_ptr<SourceCoverageView> View);

/// Add a branch subview to this view.
voidaddBranch(unsigned Line, ArrayRef<CountedRegion> Regions,
 std::unique_ptr<SourceCoverageView> View);

/// Print the code coverage information for a specific portion of a
/// source file to the output stream.
voidprint(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
bool ShowTitle, unsigned ViewDepth = 0);
};

} // namespace llvm

#endif// LLVM_COV_SOURCECOVERAGEVIEW_H