: warningStatuses_((unsigned)Warning::_NumWarnings, true),

warningsAreErrors_((unsigned)Warning::_NumWarnings, false) {

sm_.setDiagHandler(SourceErrorManager::printDiagnostic, this);

assert(bufferingEnabled_ != 0 && "unsigned counter underflow");

if (--bufferingEnabled_ != 0)

return;

// Sort all messages.

std::sort(

bufferedMessages_.begin(),

bufferedMessages_.end(),

[](const BufferedMessage &a, const BufferedMessage &b) {

// Make sure the "too many errors" message is always last.

if (a.dk == DK_Error && !a.loc.isValid() && a.msg == sTooManyErrors)

return false;

if (b.dk == DK_Error && !b.loc.isValid() && b.msg == sTooManyErrors)

return true;

return a.loc.getPointer() < b.loc.getPointer();

});

// Print them.

for (const auto &bm : bufferedMessages_) {

doPrintMessage(bm.dk, bm.loc, bm.sm, bm.msg);

for (const auto &note : bm.notes(bufferedNotes_))

doPrintMessage(note.dk, note.loc, note.sm, note.msg);

}

// Clean the buffer.

bufferedMessages_.clear();

bufferedNotes_.clear();

std::unique_ptr<llvh::MemoryBuffer> f) {

unsigned bufId = sm_.AddNewSourceBuffer(std::move(f), SMLoc{});

assert(

!isVirtualBufferId(bufId) && "unexpected virtual buf id from SourceMgr");

return bufId;

if (isVirtualBufferId(bufId))

return virtualBufferNames_[virtualBufferIdToIndex(bufId)];

else

return sm_.getMemoryBuffer(bufId)->getBufferIdentifier();

llvh::raw_ostream &OS,

const SourceCoords &coords) {

if (coords.isValid()) {

OS << getSourceUrl(coords.bufId) << ":" << coords.line << "," << coords.col;

} else {

OS << "none:0,0";

}

SourceCoords coords;

findBufferLineAndLoc(loc, coords);

dumpCoords(OS, coords);

DiagKind dk,

SMLoc loc,

SMRange sm,

const Twine &msg) {

++messageCount_[dk];

doGenMessage(dk, loc, sm, msg);

if (LLVM_UNLIKELY(dk == DK_Error && messageCount_[DK_Error] == errorLimit_)) {

errorLimitReached_ = true;

doGenMessage(DK_Error, {}, {}, sTooManyErrors);

}

hermes::SourceErrorManager::DiagKind dk,

llvh::SMLoc loc,

llvh::SMRange sm,

llvh::Twine const &msg) {

if (bufferingEnabled_) {

// If this message is a note, try to associate it with the last message.

// Note that theoretically the first buffered message could be a note, so

// we play it safe here (even though it should never happen).

if (dk == DK_Note && !bufferedMessages_.empty()) {

bufferedMessages_.back().addNote(bufferedNotes_, dk, loc, sm, msg.str());

} else {

bufferedMessages_.emplace_back(dk, loc, sm, msg.str());

}

} else {

doPrintMessage(dk, loc, sm, msg);

}

DiagKind dk,

SMLoc loc,

SMRange sm,

const Twine &msg) {

sm_.PrintMessage(

loc,

static_cast<llvh::SourceMgr::DiagKind>(dk),

msg,

sm.isValid() ? llvh::ArrayRef<SMRange>(sm)

: llvh::ArrayRef<SMRange>(llvh::None),

llvh::None,

outputOptions_.showColors);

hermes::SourceErrorManager::DiagKind dk,

llvh::SMLoc loc,

llvh::SMRange sm,

llvh::Twine const &msg,

hermes::Warning w,

Subsystem subsystem) {

assert(dk <= DK_Note);

if (suppressMessages_) {

if (*suppressMessages_ == Subsystem::Unspecified) {

return;

}

if (subsystem == *suppressMessages_) {

return;

}

}

// Suppress all messages once the error limit has been reached.

if (LLVM_UNLIKELY(errorLimitReached_))

return;

if (dk == DK_Warning && !isWarningEnabled(w)) {

lastMessageSuppressed_ = true;

return;

}

// Automatically suppress notes if the last message was suppressed.

if (dk == DK_Note && lastMessageSuppressed_)

return;

lastMessageSuppressed_ = false;

/// Optionally upgrade warnings into errors.

if (dk == DK_Warning && isWarningAnError(w)) {

dk = DK_Error;

}

assert(static_cast<unsigned>(dk) < kMessageCountSize && "bounds check");

if (externalMessageBuffer_) {

externalMessageBuffer_->addMessage(dk, loc, sm, msg);

return;

}

countAndGenMessage(dk, loc, sm, msg);

DiagKind dk,

SMLoc loc,

SMRange sm,

const Twine &msg,

Subsystem subsystem) {

message(dk, loc, sm, msg, Warning::NoWarning, subsystem);

DiagKind dk,

SMRange sm,

const Twine &msg,

Subsystem subsystem) {

message(dk, sm.Start, sm, msg, subsystem);

DiagKind dk,

SMLoc loc,

const Twine &msg,

Subsystem subsystem) {

message(dk, loc, SMRange{}, msg, subsystem);

const llvh::MemoryBuffer *buf,

SMLoc loc) {

const char *ptr = loc.getPointer();

// In the very unlikely case that `loc` points to a '\r', we skip backwards

// until we find another character, while being careful not to fall off the

// beginning of the buffer.

if (LLVM_UNLIKELY(*ptr == '\r') ||

LLVM_UNLIKELY(isUTF8ContinuationByte(*ptr))) {

const char *bufStart = buf->getBufferStart();

do {

if (LLVM_UNLIKELY(ptr == bufStart)) {

// This is highly unlikely but theoretically possible. There were only

// '\r' between `loc` and the start of the buffer.

break;

}

--ptr;

} while (*ptr == '\r' || isUTF8ContinuationByte(*ptr));

}

return SMLoc::getFromPointer(ptr);

if (!loc.isValid()) {

result.bufId = 0;

return false;

}

result.bufId = sm_.FindBufferContainingLoc(loc);

if (!result.bufId)

return false;

// Adjust the source location if necessary.

loc = adjustSourceLocation(sm_.getMemoryBuffer(result.bufId), loc);

auto lineCol = sm_.getLineAndColumn(loc, result.bufId);

result.line = lineCol.first;

result.col = lineCol.second;

return true;

llvh::SMLoc loc,

hermes::SourceErrorManager::SourceCoords &result,

bool translate) {

if (!findBufferLineAndLoc(loc, result))

return false;

if (translate && translator_)

translator_->translate(result);

return true;

if (!coords.isValid())

return {};

// TODO: optimize this with caching, etc.

auto *buffer = getSourceBuffer(coords.bufId);

if (!buffer)

return {};

const char *cur = buffer->getBufferStart();

const char *end = buffer->getBufferEnd();

// Loop until we find the line or we reach EOF.

unsigned lineNumber = 1;

const char *lineEnd;

while ((lineEnd = (const char *)std::memchr(cur, '\n', end - cur)) !=

nullptr &&

lineNumber != coords.line) {

++lineNumber;

cur = lineEnd + 1;

}

// If we didn't find LF, the end of the buffer is the end of the line.

if (!lineEnd)

lineEnd = end;

// The last line we found is [cur..lineEnd) and its number is lineNumber.

// Is it the right one?

if (lineNumber != coords.line)

return {};

// Trim a CR at start and end to account for all crazy line endings.

if (cur != lineEnd && *cur == '\r')

++cur;

if (cur != lineEnd && *(lineEnd - 1) == '\r')

--lineEnd;

// Special case for empty line.

if (cur == lineEnd) {

// Column 1 or 0 in an empty line should work.

if (coords.col <= 1)

return SMLoc::getFromPointer(cur);

return {};

}

// Check for presence of UTF-8.

bool utf8 = false;

for (const char *p = cur; p != lineEnd; ++p) {

if (LLVM_UNLIKELY(*p & 0x80)) {

utf8 = true;

break;

}

}

// ASCII is easy - just add the offset.

if (LLVM_LIKELY(!utf8)) {

// Is the column in range?

if (coords.col > (size_t)(lineEnd - cur))

return {};

return SMLoc::getFromPointer(cur + coords.col - 1);

}

// Scan for the column while accounting for multi-byte characters.

unsigned column = 0;

for (; cur != lineEnd; ++cur) {

// Skip continuation bytes.

if (isUTF8ContinuationByte(*cur))

continue;

if (++column == coords.col)

return SMLoc::getFromPointer(cur);

}

return {};

const llvh::SMDiagnostic &diag,

SourceErrorOutputOptions opts) {

// Decode our source line to UTF-32

// Ignore errors (UTF-8 errors will become replacement character)

// Don't try to decode past embedded nulls

// Map from narrow byte to column as we go

std::vector<uint32_t> narrowByteToColumn;

std::u32string sourceLine;

std::string narrowSourceLine = diag.getLineContents();

const char *cursor = narrowSourceLine.c_str();

while (*cursor) {

const char *prev = cursor;

sourceLine.push_back(decodeUTF8<true>(cursor, [](const llvh::Twine &) {}));

while (prev++ < cursor) {

narrowByteToColumn.push_back(sourceLine.size() - 1);

}

}

const size_t numColumns = sourceLine.size();

// Widening helper

auto widenColumn = [&](unsigned narrowColumn) -> unsigned {

return narrowColumn < narrowByteToColumn.size()

? narrowByteToColumn[narrowColumn]

: numColumns;

};

// Widen the caret column and ranges using our map

// Ranges are of the form [first, last)

assert(diag.getColumnNo() >= 0);

const size_t columnNo = widenColumn(diag.getColumnNo());

std::vector<std::pair<unsigned, unsigned>> ranges;

for (const auto &r : diag.getRanges()) {

ranges.emplace_back(widenColumn(r.first), widenColumn(r.second));

}

// Build the line with the caret and ranges.

std::string caretLine(numColumns + 1, ' ');

for (const auto &range : ranges) {

if (range.first < caretLine.size()) {

std::fill(

&caretLine[range.first],

&caretLine[std::min((size_t)range.second, caretLine.size())],

'~');

}

}

caretLine[std::min(size_t(columnNo), numColumns)] = '^';

caretLine.erase(caretLine.find_last_not_of(' ') + 1);

// Expand tabs to spaces in both the source and caret line

const size_t tabStop = SourceErrorOutputOptions::TabStop;

for (size_t pos = sourceLine.find('\t'); pos < sourceLine.size();

pos = sourceLine.find('\t', pos)) {

size_t expandCount = tabStop - (pos % tabStop);

sourceLine.replace(pos, 1, expandCount, ' ');

if (pos < caretLine.size()) {

// Reuse the character in the caretLine, so that tabs in tildes expand to

// more tildes

caretLine.replace(pos, 1, expandCount, caretLine[pos]);

}

pos += expandCount;

}

// Trim the lines to respect preferredMaxErrorWidth

// "Focus" around the caret, and any range intersecting it

// Note ranges are of the form [start, end) and not [start, length)

int focusStart = columnNo;

int focusLength = 1;

for (const auto &r : ranges) {

if (r.first <= size_t(columnNo) && size_t(columnNo) < r.second) {

focusStart = r.first;

focusLength = r.second - r.first;

break;

}

}

size_t desiredLineLength = std::max(

opts.preferredMaxErrorWidth,

focusLength + SourceErrorOutputOptions::MinimumSourceContext);

if (sourceLine.size() > desiredLineLength) {

int focusCenter = focusStart + focusLength / 2;

int leftTrimAmount = focusCenter - desiredLineLength / 2;

if (leftTrimAmount > 0) {

caretLine.erase(0, leftTrimAmount);

sourceLine.erase(0, leftTrimAmount);

std::fill(sourceLine.begin(), sourceLine.begin() + 3, '.');

}

if (sourceLine.size() > desiredLineLength) {

// Trim on the right

caretLine.erase(std::min(caretLine.size(), desiredLineLength));

sourceLine.erase(desiredLineLength);

std::fill(sourceLine.end() - 3, sourceLine.end(), '.');

}

}

// Convert sourceLine back to narrow

narrowSourceLine.clear();

for (uint32_t c : sourceLine) {

char buffer[UTF8CodepointMaxBytes] = {};

char *buffCursor = buffer;

encodeUTF8(buffCursor, c);

narrowSourceLine.append(buffer, buffCursor);

}

return {std::move(narrowSourceLine), std::move(caretLine)};

const llvh::SMDiagnostic &diag,

void *ctx) {

using llvh::raw_ostream;

const SourceErrorManager *self = static_cast<SourceErrorManager *>(ctx);

const SourceErrorOutputOptions opts = self->outputOptions_;

auto &S = llvh::errs();

llvh::StringRef filename = diag.getFilename();

int lineNo = diag.getLineNo();

int columnNo = diag.getColumnNo();

// Helpers to conditionally set or reset a color

auto changeColor = [&](raw_ostream::Colors color) {

if (opts.showColors)

S.changeColor(color, true);

};

auto resetColor = [&]() {

if (opts.showColors)

S.resetColor();

};

changeColor(raw_ostream::SAVEDCOLOR);

if (!filename.empty()) {

S << (filename == "-" ? "<stdin>" : filename);

if (lineNo != -1) {

S << ':' << lineNo;

if (columnNo != -1)

S << ':' << (columnNo + 1);

}

S << ": ";

}

switch (diag.getKind()) {

case llvh::SourceMgr::DK_Error:

changeColor(raw_ostream::RED);

S << "error: ";

break;

case llvh::SourceMgr::DK_Warning:

changeColor(raw_ostream::MAGENTA);

S << "warning: ";

break;

case llvh::SourceMgr::DK_Note:

changeColor(raw_ostream::BLACK);

S << "note: ";

break;

case llvh::SourceMgr::DK_Remark:

changeColor(raw_ostream::BLACK);

S << "remark: ";

break;

}

resetColor();

changeColor(raw_ostream::SAVEDCOLOR);

S << diag.getMessage() << '\n';

resetColor();

if (lineNo == -1 || columnNo == -1)

return;

std::string sourceLine;

std::string caretLine;

std::tie(sourceLine, caretLine) = buildSourceAndCaretLine(diag, opts);

// Check for non-ASCII characters, which may have a width > 1

// If we find them, don't try to show the caret line

// TODO: bravely teach buildSourceAndCaretLine to use wcwidth(), lifting this

// restriction

bool showCaret = isAllASCII(sourceLine.begin(), sourceLine.end());

S << sourceLine << '\n';

if (showCaret) {

changeColor(raw_ostream::GREEN);

S << caretLine << '\n';

resetColor();

}

// If the range is empty, return the starting point.

if (range.Start == range.End)

return range.Start;

return SMLoc::getFromPointer(range.End.getPointer() - 1);